Pyqrack

This release is only various micro-optimizations and one edge case bug fix:

- An edge case bug of `QPager::Compose()` was fixed, where qubit count was not previously correctly updated.
- In the more general case, `QPager::Compose()` has been made greedier, to sooner free memory with which it is finished, which might reduce the peaks of `QPager` memory-usage spikes.
- Micro-optimizations were made in the OpenCL program. **If you precompile OpenCL kernels, recompile your kernels, for this release!**
- A (blocking) `clFinish()` call in `QEngineOCL::DecomposeDispose()` was assessed to be unnecessary and removed, which might give a tiny improvement to the parallelism of internal and public API `Dispose()` calls.

**Again, note that If you precompile OpenCL kernels, recompile your kernels, for this release!** (I would guess that the old OpenCL program might be 100% functional anyway, but you would likely prefer to have the benefit of the new OpenCL micro-optimizations.)

This release fixes the proactive distribution of load over devices in `QPager::Compose()`, which allows it to work under `QUnit`, (as on a local test system with a NVIDIA RTX 3080 and an Intel HD, for one additional qubit over that attainable with just the RTX 3080).

This release fixes a segmentation fault in the `QUnit` over `QStabilizerHybrid` layer stack.

We seem to run into significantly fewer memory safety errors in high-width benchmarks, by replacing the use of (C++) `std::vector<QEnginePtr>.push_back()` in iteration over state vectors with a pre-allocated vector of `NULL` pointers.

After having debugged `QPager`, many systems seem significantly more susceptible to "hanging" on high-width circuits. To alleviate this, devices default to a memory usage limit of 3/4 of their global RAM, (usually equivalent to 3 out of 4 maximum allocation segments). This allocation limit can be turned up or down, per device, with the environment variable `QRACK_MAX_ALLOC_MB`. (Also consider setting `QRACK_MAX_PAGING_QB`.)

With v0.21.0, apparent `QPager` performance was significantly reduced, though the results are more correct, so a comparison to the previous bugged implementation might not be fair. However, we have prioritized improving performance in the new implementation.

v0.21.1 has about a 10% improvement in overall execution time for a representative 30 qubit QFT on an RTX 3080 GPU using `QUnit`.

QPager` in the underlying Qrack library, for multi-device or multi-allocation-segment simulation, has been extensively debugged. Its apparent performance might suffer on multi-page loads, but the tradeoff is that its results are now reliable correct, comparatively.

`QMaskFusion` layer has been totally removed from Qrack, and the corresponding `is1QbFusion` PyQrack layer option with it. The intent of `QMaskFusion` is still accomplished by `mx()`, `my()`, and `mz()`, but the layer that automatically composes these operations out of `x()`, `y()`, and `z()` calls provides no practical benefit, under any circumstances ever observed.