[ty] Support typing.TypeForm (#25334)

## Summary

`TypeForm[T]` describes a value that is a valid type expression
representing a type assignable to `T`. Unlike `type[T]`, it can describe
forms such as parameterized generics and unions, not only runtime class
objects:

```python
from typing import assert_type
from typing_extensions import TypeForm

def construct[T](form: TypeForm[T]) -> T:
    raise NotImplementedError

assert_type(construct(int), int)
assert_type(construct(list[int]), list[int])
assert_type(construct(int | str), int | str)
```

This PR adds support for `TypeForm[T]`, bringing us into alignment with
the conformance suite.

For bare `type`, we treat it as a runtime class value, but one that
doesn't promise a specific represented type, so it's valid for broad
TypeForm destinations, but not narrow ones:

```python
def use_bare_runtime_class(runtime_type: type) -> None:
    any_form: TypeForm[Any] = runtime_type
    object_form: TypeForm[object] = runtime_type
    string_form: TypeForm[str] = runtime_type  # error
```

Closes astral-sh/ty#2668.

Author: charliermarsh

crates/ty_ide/src/completion.rs

@@ -2703,7 +2703,9 @@ fn completion_kind_from_type<'db>(db: &'db dyn Db, ty: Type<'db>) -> Option<Comp
             | Type::NewTypeInstance(_)
             | Type::EnumComplement(_) => CompletionKind::Struct,
             Type::LiteralValue(literal) if literal.is_enum() => CompletionKind::Enum,
-            Type::LiteralValue(_) | Type::TypeIs(_) | Type::TypeGuard(_) => CompletionKind::Value,
+            Type::LiteralValue(_) | Type::TypeIs(_) | Type::TypeGuard(_) | Type::TypeForm(_) => {
+                CompletionKind::Value
+            }
             Type::ProtocolInstance(_) => CompletionKind::Interface,
             Type::TypeVar(_) => CompletionKind::TypeParameter,
             Type::Union(union) => union

crates/ty_python_semantic/resources/mdtest/annotations/generic_alias.md

@@ -11,6 +11,12 @@ Numbers = list[int]
 # this as `list[int]` is more helpful, though:
 reveal_type(Numbers)  # revealed: <class 'list[int]'>
 
+import types
+from typing_extensions import TypeForm
+
+generic_alias: types.GenericAlias = list[int]
+generic_alias_typeform: TypeForm = list[int]
+
 def _(numbers: Numbers) -> None:
     reveal_type(numbers)  # revealed: list[int]
 ```