[ty] implement disjointness of Callable vs SpecialForm (#18503)

## Summary

Fixes https://github.com/astral-sh/ty/issues/557

## Test Plan

Stable property tests succeed with a million iterations. Added mdtests.

---------

Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>

crates/ty_python_semantic/src/types.rs

@@ -1926,6 +1926,15 @@ impl<'db> Type<'db> {
                 true
             }
 
+            (Type::Callable(_), Type::SpecialForm(special_form))
+            | (Type::SpecialForm(special_form), Type::Callable(_)) => {
+                // A callable type is disjoint from special form types, except for special forms
+                // that are callable (like TypedDict and collection constructors).
+                // Most special forms are type constructors/annotations (like `typing.Literal`,
+                // `typing.Union`, etc.) that are subscripted, not called.
+                !special_form.is_callable()
+            }
+
             (
                 Type::Callable(_) | Type::DataclassDecorator(_) | Type::DataclassTransformer(_),
                 instance @ Type::NominalInstance(NominalInstanceType { class, .. }),

crates/ty_python_semantic/src/types/special_form.rs

@@ -247,6 +247,59 @@ impl SpecialFormType {
         self.class().to_class_literal(db)
     }
 
+    /// Return true if this special form is callable at runtime.
+    /// Most special forms are not callable (they are type constructors that are subscripted),
+    /// but some like `TypedDict` and collection constructors can be called.
+    pub(super) const fn is_callable(self) -> bool {
+        match self {
+            // TypedDict can be called as a constructor to create TypedDict types
+            Self::TypedDict
+            // Collection constructors are callable
+            // TODO actually implement support for calling them
+            | Self::ChainMap
+            | Self::Counter
+            | Self::DefaultDict
+            | Self::Deque
+            | Self::OrderedDict => true,
+
+            // All other special forms are not callable
+            Self::Annotated
+            | Self::Literal
+            | Self::LiteralString
+            | Self::Optional
+            | Self::Union
+            | Self::NoReturn
+            | Self::Never
+            | Self::Tuple
+            | Self::List
+            | Self::Dict
+            | Self::Set
+            | Self::FrozenSet
+            | Self::Type
+            | Self::Unknown
+            | Self::AlwaysTruthy
+            | Self::AlwaysFalsy
+            | Self::Not
+            | Self::Intersection
+            | Self::TypeOf
+            | Self::CallableTypeOf
+            | Self::Callable
+            | Self::TypingSelf
+            | Self::Final
+            | Self::ClassVar
+            | Self::Concatenate
+            | Self::Unpack
+            | Self::Required
+            | Self::NotRequired
+            | Self::TypeAlias
+            | Self::TypeGuard
+            | Self::TypeIs
+            | Self::ReadOnly
+            | Self::Protocol
+            | Self::Generic => false,
+        }
+    }
+
     /// Return the repr of the symbol at runtime
     pub(super) const fn repr(self) -> &'static str {
         match self {