Speed up union simplification

Union simplification (make_simplified_union) has been causing multiple performance issues (at least #9169, #12408, #12225). It can make proper subtype checks of all union items against all other items, which is O(n**2) -- with certain O(n) fast paths that cover some (but not all) problematic scenarios. Union simplification is fairly performance-critical even when we don't hit worst-case scenarios.

Here are some ideas about what we might do to improve the situation:

1. Somehow implement union simplification of multiple Instance types (at least simple ones) in close to linear time. I suspect that this is possible under some reasonable assumptions.
2. Cache negative results of proper subtype checks. I think that currently we only cache positive results (in mypy.typestate). This might have some drawbacks, such as a possible explosion of cache sizes. I assume there's a reason why we aren't currently doing this. Union simplification tends to perform many proper subtype checks with negative results.
3. Avoid doing full union simplification in some cases, perhaps based on some heuristics. Union simplification should never be semantically necessary.
4. Add fast paths for the most common union simplification operations (e.g. single item, X | None).

Start with make_simplified_union and the subtype-check caching in mypy.typestate, then review the related issues #9169, #12408, and #12225. The work is complete when union simplification is measurably faster without changing its semantics, but the issue does not specify a single implementation or benchmark.