Stop allocating GPU and pinned memory nothing reads

Three resource fixes and two latent bugs, none of which changes a computed
number.

The preprocessed image has a host copy that only a CPU engine ever reads. On
the GPU path every engine reads the device buffer instead, and rugnux always
runs the fused adaptive finder, so that host copy is allocated, zeroed and
PAGE-LOCKED for nothing - 72 MB per worker, 3.5 GB over 48 of them, and a
cudaHostRegister each, which the driver serializes. It is now skipped by the
same condition that already decides whether the device copies the image back.
ImagePreprocessorBuffer keeps the pixel count separately so size() still
answers when the mirror was not allocated.

ROIIntegrationGPU asked device 0 for the SM count it sizes its grid from, while
workers are pinned round-robin across the GPUs - so on a multi-GPU node it
could size a grid from a card it never launches on. It asks the current device
now, like every other engine.

~CudaRegisteredVector called a function that throws out of a destructor, and
the move-assignment did the same from a noexcept function. Either would abort
the process rather than report the failure, and teardown - after a device
reset, or while another exception unwinds - is exactly where cudaHostUnregister
fails. Both now use an unchecked unregister, as every other destructor in that
header already does for its own teardown call. The throwing form stays for
rebind()/unregister(), which are called from live code.

Measured on a 16M-pixel rotation dataset: unchanged space group, merged
reflection count and merging statistics.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

image_analysis/image_preprocessing/ImagePreprocessorBuffer.h

@@ -9,7 +9,15 @@
 
 class ImagePreprocessorBuffer {
 protected:
+    // The image size, kept apart from `buffer` so size() still answers when the host copy was not
+    // allocated at all (see the host_mirror constructor).
+    const size_t npixels;
     std::vector<int32_t> buffer;
+
+    // host_mirror = false leaves `buffer` empty. On the GPU path the preprocessed image lives on the
+    // device and no CPU engine reads it back, so the four-bytes-per-pixel host copy would be
+    // allocated, zeroed and page-locked for nothing - 72 MB per worker on a 16M-pixel detector.
+    ImagePreprocessorBuffer(size_t npixels, bool host_mirror);
 public:
     explicit ImagePreprocessorBuffer(size_t npixels);
     virtual ~ImagePreprocessorBuffer() = default;
@@ -23,7 +31,7 @@ public:
     const std::vector<int32_t> &getBuffer() const { return buffer; }
     int32_t &operator[](size_t i) { return buffer[i]; }
     const int32_t &operator[](size_t i) const { return buffer[i]; }
-    size_t size() const { return buffer.size(); }
+    size_t size() const { return npixels; }
 
     int32_t *data() { return buffer.data(); }
     const int32_t *data() const { return buffer.data(); }