What would be preferred aesthetically and performance wise?

This is probably a matter of preference. But performance-wise it's definitely faster to do the second one. Especially as there should be a new instance of String created for every assignment you perform.This means, you create 3 Instances of String, that are just "useless garbage".

@skiwi and @200_success put me right on my incorrect belief, that the second approach were faster. In fact, every Call to .replaceAll() creates a new Instance of String, whether you concat the next call or not.
This makes it a relatively expensive operation.

Concerning the possibility of commenting your code:
your code / regex should be "selfdocumenting" enough to not need comments.

If that is not the case, I suggest you extract at least your regexes to named constants:

tweet = tweet.replaceAll(HASHTAG_REGEX, "")
    .replaceAll("\n", " ")
    .replaceAll(DO_NOT_KNOW_WHAT_REGEX, " ")
    .replaceAll(MULTIPLE_WHITESPACE_REGEX, " ")
    .trim();

_{Thanks to @Amon for valuable critique on my indentation-style}

My recommendation for this would be to first focus on readability and then only concern yourself with performance if you know it's an issue.

I find regex hard to read myself, especially when you're just glancing at it, so my recommendation for that is to move the regexes into their own methods that have better names.

Usage:

string before = "bla bla blah"; 
string after = TweetFormatter.format(before);

System.out.println("Before: " + before + "\n");
System.out.println("After: " + after + "\n");

Implementation:

public class TweetFormatter
{
    public static string format(string tweet)
    {
        tweet = removeHashTags(tweet);
        tweet = someOtherMethod(tweet);
        tweet = convertNewlinesToSpaces(tweet);
        tweet = normalizeWhitespace(tweet);

        return tweet.trim();
    }

    private static string removeHashTags(string tweet)
    {
        return tweet.replaceAll("@\\w+|#\\w+|\\bRT\\b", "");
    }

    private static string someOtherMethod(string tweet)
    {
        return tweet.replaceAll("[^\\p{L}\\p{N} ]+", " ");
    }   

    private static string convertNewlinesToSpaces(string tweet)
    {
        return tweet.replaceAll("\n", " ");
    }

    private string string normalizeWhitespace(string tweet)
    {
        return tweet.replaceAll("\\s+", " ");
    }
}

The advantage to doing this is that if you determine that this performs too slowly, you can write unit tests to ensure the TweetFormatter behaves properly, and then refactor its innards to make it more performant without worrying about duplicated code.

As shown by skiwi each "replaceAll" call compiles a regexp pattern, then apply it to a String and finally performs the replacement.

If you pre-compile your patterns you can have your code running a bit faster (I've tried on my machine, got it 15% faster - not such a big deal but if performances are important for you, you can consider it)

You can do it in this way:

private static class ReplacementPattern {
    ReplacementPattern(Pattern pattern, String replace) {
        this.pattern = pattern;
        this.replace = replace;
    }
    Pattern pattern;
    String replace;
}

Your patterns must be initialized somewhere in your code, just once:

private List<ReplacementPattern> patterns = new ArrayList<ReplacementPattern>(4);

    patterns.add(new ReplacementPattern(Pattern.compile("@\\w+|#\\w+|\\bRT\\b"), ""));
    patterns.add(new ReplacementPattern(Pattern.compile("\n"), " "));
    patterns.add(new ReplacementPattern(Pattern.compile("[^\\p{L}\\p{N} ]+"), " "));
    patterns.add(new ReplacementPattern(Pattern.compile(" +"), " "));


private String cleanTweet(String text) {
    for (ReplacementPattern rp : patterns) {
        text = rp.pattern.matcher(text).replaceAll(rp.replace);
    }
    return text.trim();
}