"C# has been going down the same path, adding the same sorts of tricks to reduce verbosity (like type inference, auto properties, anonymous classes, closures, etc.), as well as adding functional programming techniques to simplify things in specific circumstances."

You make them sound like the same thing. To use Rich Hickey's terminology, the new features of C# tend to make things *easier* but not necessarily *simpler*. Reducing verbosity can be a worthy goal, but C# has accomplished this by piling on the features, which interact with each other poorly, if at all. The C# standard is now almost as long as the C++ standard! There are many words I could use to describe the situation, but "simple" is not one of them.

Compare Python, for example, which has also evolved to add properties, closures, etc., but during the same time period has removed old features which didn't pan out, or for which a better way was found, and has actually simplified its type system while making it more powerful. The downside of removing features, of course, is that you lose backwards compatibility of source code (though languages like C# can't and don't guarantee that, either, e.g., as everyone with a Tuple was reminded in 2010). The upside is that the language as a whole is genuinely simpler, and also more powerful: Python programs tend to be significantly shorter than similar C# programs.

Many languages other than Python share this trait, and it's not hard to find languages that are both simple and powerful. Clojure also runs on the JVM, and also has these "three major improvements", among many others. It's also far less complex than Scala. (Then again, it doesn't use curly-braces so it's obviously a terrible language that nobody should ever use.)

Based on a few years of experience writing each of Java, C#, and Python (among many other languages), and based on what I've read about Scala, I think you're absolutely correct that Scala is Java's C#. I don't think that's a good thing: everything I've heard about Scala is that it is insanely complex, especially its type system. Java might have started out as "simplicity, but no power", but someone looking to upgrade might not find "power, but no simplicity" to be very appealing, when there are several options available which offer both simplicity and power.