[ty] Support solving generics involving PEP 695 type aliases (#22678)

## Summary

Fixes type variable inference when a PEP 695 type alias is used as a
function parameter.

**Before:**
```python
type MyList[T] = list[T]
def head[T](my_list: MyList[T]) -> T: ...
reveal_type(head([1, 2]))  # Unknown
```

**After:** Correctly infers `int` by expanding `MyList[T]` to `list[T]`
during solving.

Changes in `generics.rs`:
- **Early formal expansion**: Expand parameter type aliases immediately
so underlying structure is visible for structural matching
- **Late actual expansion**: Expand argument type aliases after direct
matching attempts to preserve alias identity for `reveal_type()` and
literal promotion
- **Union induction**: Recursively match formal type against each union
element to support nested aliases like `ListOfPairs[T] = list[Pair[T]]`

The early/late expansion asymmetry is intentional: formal needs
structural visibility; actual needs identity preservation.

## Test Plan

- New tests in `aliases.md` covering simple, nested, and union alias
cases
- All 313 existing mdtests pass

Closes astral-sh/ty#1851.

Author: bxff

crates/ty_python_semantic/resources/mdtest/generics/pep695/aliases.md

@@ -328,3 +328,37 @@ def _(x: DivergentList[int]):
     d1: DivergentList[int] = [x]
     d2: DivergentList[int] = x[0]
 ```
+
+## Solving generics with type alias parameters
+
+A generic function parameter annotated with a PEP 695 type alias that contains a type variable
+should properly infer the specialization from the argument:
+
+```py
+type MyList[T] = list[T]
+type MyDict[K, V] = dict[K, V]
+
+def head[T](my_list: MyList[T]) -> T:
+    return my_list[0]
+
+def get_value[K, V](my_dict: MyDict[K, V], key: K) -> V:
+    return my_dict[key]
+
+reveal_type(head([1, 2]))  # revealed: int
+reveal_type(head(["a", "b"]))  # revealed: str
+
+d: dict[str, int] = {"a": 1}
+reveal_type(get_value(d, "a"))  # revealed: int
+```
+
+It also works in the reverse direction, where the type alias is used as the argument type:
+
+```py
+type MyList[T] = list[T]
+
+def head[T](l: list[T]) -> T:
+    return l[0]
+
+def _(x: MyList[int]):
+    reveal_type(head(x))  # revealed: int
+```

crates/ty_python_semantic/src/types/generics.rs

@@ -1769,6 +1769,12 @@ impl<'db> SpecializationBuilder<'db> {
         let formal = formal.filter_disjoint_elements(self.db, actual, self.inferable);
 
         match (formal, actual) {
+            // Expand PEP 695 type aliases in the formal type.
+            // This is necessary for solving generics like `def head[T](my_list: MyList[T]) -> T`.
+            (Type::TypeAlias(alias), _) => {
+                return self.infer_map_impl(alias.value_type(self.db), actual, polarity, f, seen);
+            }
+
             // TODO: We haven't implemented a full unification solver yet. If typevars appear in
             // multiple union elements, we ideally want to express that _only one_ of them needs to
             // match, and that we should infer the smallest type mapping that allows that.
@@ -2100,6 +2106,15 @@ impl<'db> SpecializationBuilder<'db> {
                 }
             }
 
+            // Expand type aliases in the actual type.
+            //
+            // This is placed at the end of the match block to avoid expanding the type alias
+            // when it can be matched directly against a type variable in the formal type,
+            // e.g., `reveal_type(alias)` should reveal the type alias, not its value type.
+            (formal, Type::TypeAlias(alias)) => {
+                return self.infer_map_impl(formal, alias.value_type(self.db), polarity, f, seen);
+            }
+
             // TODO: Add more forms that we can structurally induct into: type[C], callables
             _ => {}
         }