I can count on one hand the programs written in C# that I use in Linux, and those projects have to explicitly support Linux. Compared to JVM targeting projects where the experience is typically "Linux? Well shit, I don't know. Here's the jar, try it out. Oh, it works? Great!"
If I were writing a new language and had to pick one to target, from a technical perspective the CLR would seem to be the clear choice. But I don't think that is the perspective most people are coming from.
So legitimate question, is the CLR better than the JVM at cross language support and if so what makes it better?
Yes in the early days, because JVM was initially designed just for Java and many bytecodes are directly related to Java semantics.
Meaning any language that targets the JVM has to adapt their semantics to Java semantics at the bytecode level, hence the tricks mapping closures to anonymous classes as one example from many.
This got better with the introduction of new bytecodes in Java 7 and the upcoming Java 8, but it is still a Java VM at heart.
The CLR was designed as language agnostic, meaning its design had to support a good implementation of VB, C# and C++ on day one, alongside other languages from Microsoft partners like Eiffel and COBOL as two possible examples.
There is inclusive a .NET ABI for interoperability between languages, CLS (Common Language Specification).
So the bytecode is much more generic and more low level than the JVM bytecode is.
Then thanks to the work done on IronPython and IronRuby, it got the DLR part with allows for better performance of dynamic languages implementations. Since initially CLR was mostly targeted for strong typed languages.
Nowadays both platforms are quite similar in terms of language support.
1) On top of the JVM we've got Scala, Clojure, JRuby, Jython, Groovy, Fantom, very successful, very active, with big communities.
2) On top of the CLR, we've got IronRuby dead, IronPython dead, Clojure.NET almost dead, Scala.NET dead. VB is C# with a different syntax. The only partial success story is F#, executed by Microsoft and I say partial because its impact is less than Clojure, Scala or JRuby, in spite of Microsoft promoting it.
So you see, something is wrong with your assessment and you've been listening too much to marketing pamphlets.
The CLR is definitely not full of design mistakes, it's actually quite awesome. But in terms of technical arguments, the JVM is better for dynamic languages, as it can do all sorts of optimizations at runtime that the CLR is not capable of. It's not that Microsoft couldn't improve it, but C# would have nothing to gain as it was designed to not need runtime optimizations (e.g. on the JVM, AOT compiler optimizations can actually get in the way, whereas the C# engineers focus on optimizing the compiler). And the new InvokeDynamic from JDK 7 is amazing. Starting with Java 8, it will even have benefits for static languages, like Scala. Scala for example has the notion of "lazy val", which are final references initialized on first access. In the current implementation, lazy vals have a performance penalty on access, as the generated code implies synchronization on the underlying reference, however Java 8 will make it possible to declare the generated values as being effectively constants.
The JVM also has a more capable garbage collector(s) for more wasteful languages. It makes a world of difference for languages like Scala or Clojure (e.g. functional languages use a lot of persistent immutable data-structures which generate a lot more junk than their imperative counterparts).
On the community side, for the JVM there are more capable libraries for generating bytecode. Also the ECMA standard has been kind of incomplete. For example Mono had to use for a long time their own format for the debugging symbols, while slowly reverse-engineering Microsoft's format. The debugging symbols on the JVM are documented and directly a part of the generated bytecode. Sun made many good choices here too. A JAR is just a zip containing .class files and other resources. It's definitely easier to generate JARs than it is to generate DLLs. I think language developers have a much easier time generating code for the JVM.
There is one feature of the CLR that stands in the way of dynamic languages and that is the reified generics support. The JVM has fewer restrictions, although in truth both suck for languages that are not Java or C#.
So in a head to head on tools + community + buyin from multiple vendors, the JVM wins, hard.