[red-knot] Flatten Type::Callable into four Type variants

[AlexWaygood]

Summary

Currently our Type::Callable wraps a four-variant CallableType enum. But as time has gone on, I think we've found that the four variants in CallableType are really more different to each other than they are similar to each other:

• GeneralCallableType is a structural type describing all callable types with a certain signature, but the other three types are "literal types", more similar to the FunctionLiteral variant
• GeneralCallableType is not a singleton or a single-valued type, but the other three are all single-valued types (WrapperDescriptorDunderGet is even a singleton type)
• GeneralCallableType has (or should have) ambiguous truthiness, but all possible inhabitants of the other three types are always truthy.
• As a structural type, GeneralCallableType can contain inner unions and intersections that must be sorted in some contexts in our internal model, but this is not true for the other three variants.

This PR flattens Type::Callable into four distinct Type:: variants. In the process, it fixes a number of latent bugs that were concealed by the current architecture but are laid bare by the refactor. Unit tests for these bugs are included in the PR.

[github-actions]

mypy_primer results

No ecosystem changes detected ✅

[AlexWaygood]

Some other notes:

• This structure more accurately reflects the fact that lots of the Type variants have possible inhabitants that would also inhabit Callable (instances can be callable, class objects are nearly always callable, same for type[] types) -- the distinction implied by the current structure that there are "4 callable types" and all other variants do therefore not represent "callable types" is incorrect
• This doesn't fix [red-knot] Differently ordered unions that include Callable types are not always considered equivalent  #17058, but it should make it easier to fix that issue (at least how I'm currently thinking of fixing it!)

[carljm]

Nice, yeah I think this structure is less error-prone: avoids grouping very different types together in a way that makes it too easy to wrongly handle them all identically.

[dhruvmanila]

Thanks Alex for doing this! I still want to take a stab at merging the types to reduce the number of variants but that's something for later.

[sharkdp]

I still want to take a stab at merging the types to reduce the number of variants but that's something for later.

It would be great if we could postpone this until after #17017 has been merged; that PR makes major changes to two of these callable types, and rebasing on top of this branch here was a significant amount of work already. But in general, that sounds like a good idea 👍