As a consumer of `get_type_hints()` I think it'd be valuable to even have partially resolved types. My use case is that I provide an `Annotated` alias with a marker, and all I care about when inspecting user type hints is whether or not the arguments of an `Annotated` type contains my marker object. So ideally the fallback to an unresolved string or a sentinel object such as the proposed `typing.Unresolvable` should happen at the "lowest resolvable level" so that what can be resolved isn't lost.


By example, I'm saying that I think that this code:

    marker = object()

    def dec(cls):
        print(get_type_hints(cls))
        return cls

    @dec
    class A(abc.ABC):
        forward: Annotated[B, marker]

    class B:
        ...

Should produce:

    {"forward": Annotated[Unresolvable["B"], marker]}

I guess this would apply in situations where for instance a part of a union isn't resolvable too. If we have a union A|B where A is resolvable and B isn't, it should be resolved to:

    A | Unresolvable["B"]

And not to:

    Unresolvable["A | B"]

(I think for this perspective it's irrelevant whether unresolved types have a sentinel type or are just represented as strings).

(Here's the library that's my use case for the curious: https://github.com/antonagestam/abcattrs)