gh-141388: Fully support non-function callables as annotate functions

[dr-carlos]

• Any callable can be used as an __annotate__ function in 3.14, but annotationlib will start throwing errors if the format is not implemented.
• This is an initial implementation to support them as first-class citizens included here, mostly in call_annotate_function()
• Currently this implementation supports: methods, class/static methods, class instances that are callable, classes and generics themselves, partial, wrapped, singledispatch, and cached functions. 'Builtin' (C) callables can't really be supported because they have no __code__, __globals__, etc., so a ForwardRef or stringification using the current techniques is impossible. Let me know if there are any more callables to implement, some more special-casing will probably be required.
• Initial tests are present but not thorough. It should work for all parts of annotationlib, but tests are mostly present on call_annotate_function() for now.
• Opening a PR now to seek feedback on the implementation and decide on whether the extra complexity is worth it. If there is interest, I'll add more thorough tests, etc.

• Issue: __annotate__ Functions don't actually need to be functions #141388

[dr-carlos]

Current status: overall, there is a decent amount of special-casing going on to fully support various callable types. But at this point, it supports most stdlib callables (at least, the ones, I could think of), except for C functions which don't have __code__ or __globals__ so can never work with Forwardref/_Stringifier. Some better error messages would be good for those types. More testing is definitely necessary to ensure full support.

[dr-carlos]

This means that only the __init__ method is used for fake global namespaces when a class is used as an annotate function. Maybe the __new__ method should also count? Just adds a bit more complexity.

[dr-carlos]

This feels like a poorly named function. Need some way tof describing that we're calling the full annotate function (annotate) based on the part of it that we compiled previously (func) with the given args (usually the format, unless we're recursively calling).

[dr-carlos]

I've decided to take this PR out of draft mode as the tests are now pretty comprehensive and every stdlib callable I could think of is now supported where possible.
Open issues:

• New internal function naming is possibly not great?
• Classes as annotate functions currently only use the __init__ method for fake globals. The __new__ method is also called - should fake globals be inserted here too?
• @functools.singledispatch functions don't work with fake globals because of the singledispatch.wrapper() function is stored in the __closure__ and annotationlib thinks this needs to be stringified. Is this an issue?
• And I'll need to write up some documentation when I've got time.