rotation merge: helper buffers wait for the probe pass beside them, as the engine's own do

The intermittent "out of GPU memory" on the 3600-frame cbf.gz set (about one run in three on a 16 GB
card, base included) was caught with allocation backtraces: FitErrorModelGPU's 42.8 MB in
MergeAndStats failed while the speculative geometry probe (GPUWorkBeside) held its FFT indexers on
the same card. The engine's own arrays (RotationScaleMergeGPU Impl::Alloc) wait for such work to end
and ask again; the merge's helpers - ErrorModelGPU, WilsonOutliersGPU, PairSortGPU and the cub
scratch of the engine itself - allocated directly and failed at once.

CudaAlloc::SynchronousAfterWorkBeside: Synchronous, and where the card is full after the pool is
trimmed, it waits for the GPU work beside the main line (wait_for_gpu_work_beside, 10 min as for
the engine) and asks once more. The four merge files use it. Only the probe passes register
GPUWorkBeside and they index only, so none of them merges and nothing waits for itself. When a
buffer is allocated is all that changes; what is computed is not.

Catch2 CudaDevicePtr_AfterWorkBesideWaitsForItsMemory: with the card filled by work beside, a
Synchronous buffer fails and a SynchronousAfterWorkBeside one gets its memory once the work ends.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EizBKhTqrAYago9KJG3dA3

tests/CUDAMemHelpersTest.cpp

@@ -206,6 +206,39 @@ TEST_CASE("IndexerThreadPool_FFTIndexerWaitsForGPUWorkBeside", "[CUDAMemHelpers]
     }
 }
 
+// A merge helper's buffer that finds the card full while a probe pass holds the rest of it waits for
+// that work to end and its memory to come back (CudaAlloc::SynchronousAfterWorkBeside); a plain
+// synchronous one fails at once.
+TEST_CASE("CudaDevicePtr_AfterWorkBesideWaitsForItsMemory", "[CUDAMemHelpers]") {
+    if (get_gpu_count() == 0)
+        SKIP("no GPU");
+    std::vector<CudaDevicePtr<uint8_t>> held;
+    const auto fill = [&] {
+        for (size_t chunk = size_t(256) << 20; chunk >= (size_t(1) << 20); chunk /= 2)
+            while (true) {
+                try {
+                    held.emplace_back(chunk, CudaAlloc::Synchronous);
+                } catch (const JFJochException &) {
+                    break;
+                }
+            }
+    };
+    constexpr size_t BYTES = size_t(64) << 20;
+    {
+        std::optional<GPUWorkBeside> work(std::in_place);
+        fill();
+        CHECK_THROWS_AS(CudaDevicePtr<uint8_t>(BYTES, CudaAlloc::Synchronous), JFJochException);
+        std::thread ends([&] {
+            std::this_thread::sleep_for(std::chrono::milliseconds(500));
+            held.clear();
+            work.reset();
+        });
+        CHECK_NOTHROW(CudaDevicePtr<uint8_t>(BYTES, CudaAlloc::SynchronousAfterWorkBeside));
+        ends.join();
+    }
+    cuda_trim_allocation_pool();
+}
+
 #endif
 
 // A merge that finds the card full waits for the GPU work running beside it: until the last one