Summary

We currently treat the members declared on every enum as its complete runtime domain. That assumption does not hold for Flag and IntFlag, which also have zero and unnamed combinations, or for enums whose custom _missing_ method or metaclass can create additional members. As a result, we can incorrectly treat a one-member enum as a singleton, widen all declared members to the nominal enum, erase a non-empty complement, or consider a match over the declared members exhaustive.

This adds a members_are_exhaustive property to EnumClassLiteral and uses it wherever we rely on an enum being a finite set: complement construction, union simplification, singleton detection, finite-alternative narrowing, and match exhaustiveness. Open enums retain the nominal remainder after known members are excluded.

Explicit membership tests remain precise when the enum uses identity comparison. For example, a metaclass may add INJECTED, but testing against ONLY still establishes that exact member on the positive branch and excludes only that member on the negative branch:

class OpenEnum(Enum, metaclass=InjectingEnumMeta):
    ONLY = 1

def check(value: OpenEnum):
    if value in (OpenEnum.ONLY,):
        reveal_type(value)  # Literal[OpenEnum.ONLY]
    else:
        reveal_type(value)  # OpenEnum & ~Literal[OpenEnum.ONLY]

This is the semantic foundation split out of #26270; that PR adds the compact same-enum comparison path on top.