An interesting change in the .Net 4.0 framework is the new System.Text.StringBuilder implementation. The .Net 1.0-era version has been ditched (it was basically an unsafe string* with an exponential memory allocation strategy on append).

The new implementation is actually a linked list of StringBuilder instances, with the current instance pointing to the last part of the string. This strategy favors insertion speed as the list always point to the latest piece of data that was inserted (it's a reversed linked list if you will).

Let's dig deeper in the implications of the .Net 4.0 System.Text.StringBuilder implementation.

ToString implementation
The implementation of the StringBuilder.ToString method just creates an unsafe string pointer, then populates the string from end to beginning by walking each "Chunk" in the linked list.

Conclusions
The .Net Framework V2.0 implementation of System.Text.StringBuilder is optimized towards conservative memory use and a high performance ToString() implementation, whereas the .Net 4.0 version of StringBuidler is built for high-performance Append operations. The .Net 4.0 framework StringBuilder.Append is approximatively 1.7 times faster than the 2.0 version.
The ToString calls are virtually free for each compared to the time it takes for an append operation, although the 2.0 framework edges-out 4.0 due to the fact that it's actually a wrapper around an unsafe string pointer in 2.0 and a linked list in 4.0.
For any other insertion scenario, once again, 2.0 wins hand-up against 4.0, but one has to consider the fact that real-world uses of StringBuilder reveal that the most likely use case is multiple Append calls followed by a final ToString() call. On paper, .Net 4.0's implementation is slower than .Net 2.0's, but in fine, overall performance is much nicer in 4.0.

This kind of real-world profiling and performance tweaking is pervasive throughout the 4.0 Framework and make it a really interesting upgrade. Now go on and have fun fixing all these StringBuidler.Insert optimizations you added in your 2.0-era code!

You are correct, the change is to make it a tiny bit faster when appending. All other cases are worse.

And this is a concious decision. Why? Well think about how you typically use StringBuilder: by repeatedly calling Append, our case #1, and very rarely calling Insert (case 2 for index 0 and 3 for index >0 and < Length).