Top-down typing strategy - is there a name for this?
There is no top-down or bottom-up typing strategy when defining a language. It is an implementation issue. A type system will
only define operator operand constraints on your AST. The kind
constraints is fixed by the type system and is part of the design of
the language. It can be very simple as in older languages, or be a
sophisticated logical system. Even when simple, it can be seen as a
logical system. Your AST may be seen as a proof tree in that logical
system, where the nodes are to be decorated by types, that may be seen as logical
propositions proved by by the sub-tree dominated by that node . For example, the type int found for an expression is
a predicate satisfied by the expression.

So you can associate type inference rules to the operators of your
AST. For example if you have an AST operator +  with two operands,
you can associate (among others) the inference rule: 
$X::int \,\wedge\, Y::int \;\Rightarrow\; X+Y::int$

Defining the type system of a language amount to defining such rules
for all AST operators where that make sense, i.e. involved with the
type system.

Type checking your program consists in finding a type for each
(relevant) AST node, such that that there is an inference
rule (associated to the operator of that node) that is satisfied by
the node type and the types of its operands.

This can be done with top-down or bottom-up algorithms, or any
mix. That is only a matter of finding efficient algorithms. But the
checking strategy is an implementation issue, not a language
definition issue. However, it is advisable to choose a type system
that allows for a tractable type checking strategy.

Note that the types may not be all completely defined by the type system,
and the checking strategy may actually infer the "details" of these
types, in particular by means of unification techniques.

The above description may not seem too complex (I hope). One hidden
aspect, that makes the whole thing a lot more interesting, is that
in static typing (particularly) all occurences of the same variable
must have the same type, which introduces additional constraints.
But getting into the details is too much for a normally sized answer.

For more about this, you should look for type inference.