TypeForm: Early-reject functions and modules in try_parse_as_type_expression()

Add a second fast-rejection filter: a string literal that is an identifier
naming a FuncDef, OverloadedFuncDef, or MypyFile is a function or module, never
a type expression. Reject it before the expensive full-parse block.

On mypy's self-check this rejects 48 of the identifier-string literals that
reach the full-parse block (e.g. builtin functions like "classmethod",
"staticmethod", "hash"; user functions; module names like "platform"), all of
which were failing full parses.

Unlike the Var-value filter, this check is a single isinstance with no expensive
follow-on work, and FuncDef/OverloadedFuncDef/MypyFile are mutually exclusive
with the other early-reject node kinds, so it is freely positionable and its
rejection count is order-independent. It is placed by descending rejection
frequency: after the Var-value filter (~157) and before the placeholder check
(~23), i.e. the final order is

    unbound type variable (~951) -> value Var (~157)
        -> function/module (~48) -> placeholder (~23)

No companion guard is needed (a function or module name is never a valid type,
so nothing valid is rejected; check-typeform and testsemanal unchanged).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: davidfstr

mypy/semanal.py

@@ -8100,13 +8100,13 @@ def try_parse_as_type_expression(self, maybe_type_expr: Expression) -> None:
                     return
                 else:  # sym is not None
                     node = sym.node  # cache
-                    # The following early-reject checks are mutually exclusive
-                    # (a node is at most one of an unbound type variable, a value
-                    # Var, or a placeholder), so their order never affects which
-                    # expressions are rejected. They are ordered by descending
-                    # rejection frequency (measured on mypy's self-check) so the
-                    # commonest rejections exit first: unbound type variables
-                    # (~951) >> value Vars (~157) > placeholders (~23).
+                    # The following early-reject checks are mutually exclusive,
+                    # ordered by decreasing rejection frequency (measured on
+                    # mypy's self-check) so the commonest rejections exit first.
+                    # - TypeVarExpr, TypeVarTupleExpr, ParamSpecExpr (~951)
+                    # - Var (~157)
+                    # - FuncDef, OverloadedFuncDef, MypyFile (~48)
+                    # - PlaceholderNode (~23)
                     unbound_tvar_or_paramspec = (
                         isinstance(node, (TypeVarExpr, TypeVarTupleExpr, ParamSpecExpr))
                         and self.tvar_scope.get_binding(sym) is None
@@ -8127,6 +8127,10 @@ def try_parse_as_type_expression(self, maybe_type_expr: Expression) -> None:
                         # not a type expression.
                         maybe_type_expr.as_type = None
                         return
+                    if isinstance(node, (FuncDef, OverloadedFuncDef, MypyFile)):
+                        # Functions and modules are never type expressions.
+                        maybe_type_expr.as_type = None
+                        return
                     if isinstance(node, PlaceholderNode) and not node.becomes_typeinfo:
                         # Either:
                         # 1. f'Cannot resolve name "{t.name}" (possible cyclic definition)'