[red-knot] Make is_subtype_of exhaustive

[AlexWaygood]

Summary

This PR removes the fallback _ branch at the end of Type::is_subtype_of(): the function now uses an exhaustive match over the first element of the (self, target) pair. This means that we can have much more confidence that we've covered all cases, and it means that it's impossible to forget to update this function if we add more variants to Type in the future (which we will).

The PR reworks our handling of most literal types in the match statement so that they explicitly fallback to builtin types. This has several advantages:

• We now understand that Type::ModuleLiteral("typing") is a subtype of types.ModuleType
• We now understand that Type::SliceLiteral([:2]) is a subtype of builtins.slice
• We now understand that all heterogeneous tuple types are subtypes of Type::Instance(Tuple) (which represents the static set of all possible tuples, so in Python type annotations it would be written as tuple[object, ...])
• We will naturally understand that all string literal types are subtypes of typing.Sequence as soon as we understand generics -- we won't have to make any manual updates to this function
• We can get rid of the explicit handling of builtins.object being the top type from the function; we now naturally understand this without any special-casing due to the fact that we understand that all classes have object in their MROs.

Test Plan

Several new subtyping tests have been added, and all existing tests pass.

[github-actions]

ruff-ecosystem results

Linter (stable)

✅ ecosystem check detected no linter changes.

Linter (preview)

✅ ecosystem check detected no linter changes.

[carljm]

Awesome, thank you!!

[AlexWaygood]

Thanks again! Would appreciate it if somebody could take another quick look before I land, since this is all quite subtle stuff

[carljm]

Looks good to me!

Did you re-run the property tests on the latest version of the PR?

[AlexWaygood]

Okay, I had to add a couple of new branches to is_disjoint_from to make the property tests happy (we weren't recognising that tuple[()] was disjoint from Literal[object], which was causing is_subtype_from not to be transitive w.r.t. intersections, since the Type::Intersection branch in is_subtype_of calls is_disjoint_from if there are negative elements in the intersection).

This PR now causes no new property-test failures relative to main! I tested using this invocation:

QUICKCHECK_TESTS=100000 cargo test -p red_knot_python_semantic -- --ignored types::property_tests::stable

The types::property_tests::stable::assignable_to_is_reflexive still fails instantly on this branch, but it also fails on main, so I didn't look at that too much. All other property tests pass.

[carljm]

Looks good, thank you!