CUDA: Replace CachedPTX and CachedCUFunction with CUDACodeLibrary functionality - #6769

The CUDA Code Library will permit linking for a CC other than the
current device - this change to the linker in driver.py supports
specifying the CC to link for, where the default is the CC of the
current device.

The kernel invoked in the test is sync_group, but then the definitions
of this_grid are checked - the definitions of sync_group should be
checked instead.

This commit removes `CachedPTX` and `CachedCUFunction`, replacing them with
additions to the `CUDACodeLibrary`. This aligns the CUDA target with
more of the infrastructure in the core of Numba, simplifies the
organization of code generation and caching, and provides some other
benefits. Generally it lays the foundation for implementations of
on-disk caching of compiled kernels, ahead-of-time compilation, and
improving debugging support for CUDA kernels. Some specific advantages
of the new implementation:

- Although the `CUDACodeLibrary` can assume that code is to be generated
  for the current device (as is required to re-implement the behaviour
  of `CachedPTX` and `CachedCUFunction`), it is also possible to specify
  the compute capability (for PTX and cubins) for which the result
  should be returned. This aims towards avoiding interacting with a CUDA
  context at all for PTX and cubin generation - however, the latter will
  require further work to avoid using the Driver API for linking PTX,
  such as using the PTX Compiler API
  (https://docs.nvidia.com/cuda/ptx-compiler-api/index.html) instead. I
  did think about creating a `JITCUDACodeLibrary` class that contains
  all the context interactions, so that there are none in the base
  class, but until there's an actual implementation of a putative
  `AOTCUDACodeLibrary` this just feels like premature abstraction.
- The setting of NVVM options is easier to keep consistent - the options
  are initialized and placed into the flags in the compiler state, and
  are set in the code library when it is initialized. This avoids code
  being generated by a code library with a potentially different set of
  flags than the one it used earlier, as was possible with the old
  `Cached*` classes.
- Serializing a `CUDACodeLibrary` also serializes the cubins (which are
  just ELF files), which the `CachedCUFunction` class did not.

Some other notes on the changes:

- The `_func` member and property has been removed, and has not been
  replaced by anything. It could have been replaced by providing access
  to the code library of a dispatcher or kernel object, but instead I'd
  like to discourage poking about at the internals of these objects.
  This requires a slight change in `ForAll.compute_thread_per_block`
  which is a little less than perfect, but it seems no worse than it was
  before.
- Because of the initialization of a CUDA code library requiring the
  NVVM options, it was necessary to create a CUDA flags class and a pass
  to set up the code library with the NVVM options from the flags which
  runs just prior to the `NativeLowering` pass.

The idea behind deprecating this was to prevent a mismatch between
compiled code that is executed and code produced by the `inspect_ptx()`
function - however, as device functions aren't materialized standalone
(they are always part of a kernel), there is no risk of this mismatch.
Instead, `inspect_ptx()` stands as a useful mechanism for obtaining PTX
code for a device function if required - noting that `compile_ptx()`
does provide a better interface, so this whole function may be
deprecated / removed in future.