It is probably more that Kotlin's order breaks with the most common ordering, and at the cost of more characters. Not to mention the needless variation that has come along with it (e.g. : vs ->)
Having the identifier first makes it easier to parse unambiguously; the C syntax has been historically criticized for not being context-free because of stuff like "A * B" being impossible to parse correctly without knowing whether A is a type or not. While Java doesn't have the equivalent problem, Kotlin keeps its options open wrt future syntactic extensions for type names.
Identifier-first can also be a lot more readable when gnarly (and thus lengthy) types are involved, since you don't have to scan the line to find it. It makes for neater-looking code with multiple declarations one after another, too.
As far as commonality, both syntaxes are very common, and have been so historically as well (roughly speaking, C vs Pascal syntax families). It should also be noted that most new languages go for identifier-first, so if anything, it's more future-proof in this sense.
There are plenty of old languages using it. Pascal/Delphi, Ada etc. That's where the current crop of languages got that syntax from, it's not like it came out of the blue all of a sudden.
And I already explained the reasoning. No, it's not to avoid the lawsuit, it's because many people genuinely find it more readable for various reasons. Which is why it keeps showing up in all kinds of languages that are otherwise wildly different syntactically.
Yes, there are older languages using Pascal style declaration, but any of C,C++,Java dwarf it in terms of popularity and general exposure (thus my use of the term "common").
And again, in the latter part I'm talking about Kotlin's use of 'fun' and ':'.
My comment had nothing to do with lambdas. The point is that Kotlin uses fun and : instead of fn/func and ->, which is a needless and tedious break with other modern languages using Pascal-style function declaration.
Using val instead of let is similarly off-putting.
