The "spiral" type declaration syntax from C is hard to parse, both for humans and machines. That's probably why even C++ is moving away from it:

     C              modern C++
  "int foo[5]" -> "array<int,5> foo"

It's easy to criticize simple examples like the one above, since the C++ (or Rust) version is longer than the C declaration, but consider something like this:

  char *(*(**foo[][8])())[];

and the idiomatic Rust equivalent:

  let foo: Vec<[Option<fn() -> Vec<String>>; 8]> = Vec::new();

The later can be parsed quite trivially by descending into the type declaration. It's also visible at a glimpse, that the top-level type is a Vec and you can also easily spot the lambda and it's signature.

Another ergonomic aspect of the Rust syntax is that you can easily copy the raw type, without the variable name:

  Vec<[Option<fn() -> Vec<String>>; 8]>

While the standalone C type looks like this:

  char *(*(**[][8])())[]

which is quite a mess to untangle ;)

Also, I think C# is generally closer to Rust than to C when it comes to the type syntax. A rough equivalent to the previous example would be:

  var foo = new List<Func<List<string>>?[]>();

I can't deny that "?" is more ergonomic than Rust's "Option<T>", but C# has also a way less expressive type system than Rust or C++, so pick your poison.

        int[] foo
        |   |  |
        |   |  foo 
        |   is an array  
        of ints