This is pretty much the only code formatting rule that I have found actually makes a noticeable impact on readability and it takes almost no effort (assuming your code editor doesn't start a fight with you over it).
It is good programming language design to have names appear in a consistent position in declarations/definitions. The rationale is straightforward: you have a nice visual anchor (a curly brace or just a hanging indentation) that you can use to immediately find the start of the name. You don't have to actually parse the language when scanning through a file the find the name.
It's the same as when you are formatting a document: when you start a new section you put the name up front in boldface--often on its own line--not buried somewhere, undifferentiated, in a long sentence.
Early C had very terse signatures: return types were optional and argument types were declared after the signature. Names also tended to be very short. This mitigated the impact of having an occasional return type offsetting the name.
double dot(x, y);
Is still pretty digestible.
C++ made this a bit worse. It moved argument type specifications into signatures making signatures longer. This syntax was later adopted during the standardization of C.
static struct origin *find_origin(struct scoreboard *sb,
struct commit *parent,
struct origin *origin)
is less digestible, but not too bad. (Excerpt from Git)
Now consider modern programming practices with long, descriptive names and parametrized types and see how this choice has become disastrous. An example from a Boost header:
template <class A1, class A2, class A3, class A4, class A5, class A6>
inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&)
typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type result_type;
If you are writing generic code, signatures like that aren't even out of the ordinary. You can find examples of much worse cases than this without trying too hard.
C, C++, and their derivatives, Java and C#, seem to be the exceptions to having readable declarations/definitions. Their popular predecessors and peers (Fortran, ALGOL, Pascal) placed names before result types and, thankfully, many of their successors (Go, Scala, TypeScript, and Swift to name a few) have chosen more readable syntaxes as well.