Exhaustiveness checking for match statements

[JukkaL]

Closes #12010.

Mypy can now detect if a match statement covers all the possible values.
Example:

def f(x: int | str) -> int:
    match x:
        case str():
            return 0
        case int():
            return 1
    # Mypy knows that we can't reach here

Most of the work was done by @freundTech. I did various minor updates
and changes to tests.

This doesn't handle some cases properly, including these:

1. We don't recognize that match [*args] fully covers a list type
2. Fake intersections don't work quite right (some tests are skipped)
3. We assume enums don't have custom __eq__ methods

[jhance]

I think list(.items()) is more idiomatic (and probably cheaper) python

[jhance]

Nobody ever passes True here. Is this deadcode?

[jhance]

Seems fine, but some minor tweaks.

[github-actions]

Diff from mypy_primer, showing the effect of this PR on open source code:

pylox (https://github.com/sco1/pylox)
- pylox/containers/base.py:62: error: Missing return statement  [return]
- pylox/containers/array.py:163: error: Missing return statement  [return]
- pylox/interpreter.py:230: error: Missing return statement  [return]
- pylox/interpreter.py:258: error: Missing return statement  [return]

[tmke8]

This doesn't seem to work:

from enum import Enum, auto

class E1(Enum):
    a = auto()
    b = auto()

class E2(Enum):
    x = auto()
    y = auto()

def f(x: tuple[E1, E2]) -> int:
    match x:
        case (E1.a, E2.x):
            return 0
        case (E1.a, E2.y):
            return 1
        case (E1.b, E2.x):
            return 2
        case (E1.b, E2.y):
            return 3

output:

match_test.py:11: error: Missing return statement

but it's probably too difficult to support...

[JukkaL]

but it's probably too difficult to support...

Yeah, this seems a bit too complex for now. Since enums are internally expanded into unions of literal types to support exhaustiveness checking, an N-tuple of enums with M items each could be expanded a union of M**N items, which could become impractically large (and slow to process).