TypeForm: Reorder identifier-string early-reject checks by rejection frequency

Move the unbound-type-variable check ahead of the PlaceholderNode check (and
ahead of the Var-value filter added in the previous commit) in
SemanticAnalyzer.try_parse_as_type_expression(). Final order:

    unbound type variable  ->  value Var  ->  placeholder

These three checks are mutually exclusive -- a node is at most one of a
TypeVarExpr/ParamSpecExpr, a Var, or a PlaceholderNode -- so reordering cannot
change which expressions are rejected (verified: check-typeform and testsemanal
unchanged). Ordering them by descending rejection frequency, as measured on
mypy's self-check (unbound type vars ~951 >> value Vars ~157 > placeholders
~23), lets the commonest rejections exit first and minimizes total check
evaluations (~2700 -> ~1750 cheap isinstance calls over the self-check).

The win is below perf_compare's noise floor on its own (~10us), but the
reordering is free and behavior-preserving, and it makes the final ordering
self-documenting. A rationale comment is added at the head of the block.

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

Author: davidfstr

mypy/semanal.py

@@ -8100,12 +8100,13 @@ def try_parse_as_type_expression(self, maybe_type_expr: Expression) -> None:
                     return
                 else:  # sym is not None
                     node = sym.node  # cache
-                    if isinstance(node, PlaceholderNode) and not node.becomes_typeinfo:
-                        # Either:
-                        # 1. f'Cannot resolve name "{t.name}" (possible cyclic definition)'
-                        # 2. Reference to an unknown placeholder node.
-                        maybe_type_expr.as_type = None
-                        return
+                    # 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).
                     unbound_tvar_or_paramspec = (
                         isinstance(node, (TypeVarExpr, TypeVarTupleExpr, ParamSpecExpr))
                         and self.tvar_scope.get_binding(sym) is None
@@ -8126,6 +8127,12 @@ 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, PlaceholderNode) and not node.becomes_typeinfo:
+                        # Either:
+                        # 1. f'Cannot resolve name "{t.name}" (possible cyclic definition)'
+                        # 2. Reference to an unknown placeholder node.
+                        maybe_type_expr.as_type = None
+                        return
             else:  # does not look like an identifier
                 if '"' in str_value or "'" in str_value:
                     # Only valid inside a Literal[...] or Annotated[..., ...] type