CUDA Dispatcher refactor 2: inherit from dispatcher.Dispatcher - #7815

(Note: based on #7814 - it should be easier to tell the differences once that is merged - in the meantime this comparison shows the changes unique to this PR)

The main accomplishment of this PR is to make the CUDA dispatcher inherit from numba.core.dispatcher.Dispatcher and reuse as much of its logic as possible, rather than duplicating it (and also to serve as a base for implementing on-disk caching, AOT compilation, better support for the high-level extension API, etc.).

This necessitates a set of individual changes that accompany the main change:

• Creation of a CUDACompileResult, which reports its entry point as its id - this is because certain functions expect compile results to have entry points - however, this isn't true for CUDA because you can't enter a CUDA kernel through the C-layer dispatcher. Using the id gives each CUDA compile result a unique identifier.
• A small change to compile_result to factor out sanitizing the entries that go into the compile result, so that this logic can be shared between the core and the CUDA target.
• Changes to numba.cuda.decorators so it is responsible for handling signatures and compilation - the CUDA dispatcher no longer needs to be aware of signatures, and this behaviour mirrors the CPU target. CUDA still only supports one signature, but this can now be more easily changed in future.
• Fixes to the setup of the extensions target option, so that the CUDA dispatcher no longer needs to make a strange "defensive copy".
• Two additions to _Kernel so that they have the objectmode and entry_point properties, as if they were compile results - this is because overloads are expected to be compile results by some of the core dispatcher logic.
• Some refactors to ForAll that make the terminology more representative (but no functional change).
• Fix a very strange "how did it ever work"-style bug in resolve_value_type, where it was wrapping a CPU dispatcher in a CUDA dispatcher instead of wrapping the Python function in a CUDA dispatcher when calling an @njit function from a @cuda.jit function.
• Add test of docstrings for CUDA dispatchers (Use importlib to load numba extensions #5209).

Fixes #7741.

Description prior to editing, kept for reference:

Fixes #5902.

To do:

• Resolve the issue with _make_finalizer - possibly one of:
  • be certain that a dummy finalizer is fine,
  • remove the finalization altogether if it's no longer needed (perhaps this is an old Python / Python 2 remnant)
  • implement a custom non-dummy finalizer
  • make _Kernel pretend to be a CompileResult a bit more by giving it an entry_point.
• Add a test that cuda.jit does NOT preserve the original __doc__ and __module__ of the decorated function #5902 is fixed (I have only manually verified it so far).