rugnux: fixes from the rc173 pre-push scan

- RigidBodyGPU gather: AxisBrickBound undercounted by one where a box wraps
  past a partial last brick (n = 17: points 15, 16, 0 fall in bricks 1, 2, 0);
  the bound is now +2, and axis_bricks reports an overflow that Density()
  turns into a failure (-> CPU fallback) instead of dropping a brick.
  Exhaustive host test over n <= 64.
- RigidBodyTargetGPU::Residuals tests for an empty zone before launching
  Fcalc/Fmask (a 0-block grid).
- The pool engine is held by an RAII lease, returned if the constructor throws.
- The engine's stream is a CudaStream member (priority argument added), so it
  is not leaked when an allocation in the constructor throws.
- FitSolvent's "five or fewer strong reflections" case throws its own type,
  and only that is caught for the host scale.
- Hot pixels: the per-pixel counters are 16-bit, so the pre-scan sample is
  clamped to 65535 frames; no rings -> no 0-block sector/ring launches.
- PostRefine commit gate: fewer than two held-out positions refuse with
  their own reason; an excitation family of fewer than two values no longer
  refuses (its SE was NaN). No set of the r6-pooled battery reaches either
  case (smallest joint fit: ~2400 events, all SEs finite).
- Tests: ModelScaleGPU uploads on the fits' stream and accepts a near-tie's
  neighbouring grid point at the CPU winner's R; [gpu] rigid-body cases SKIP
  when the card is busy rather than fail.
- THIRD_PARTY_NOTICES: bitshuffle h-perf copyright holder is Kal Conley.

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

tests/ModelScaleGPUTest.cpp

@@ -186,8 +186,12 @@ struct GpuPoints {
             for (int j = 0; j < 3; j++)
                 frac[3 * i + j] = s.cell.frac.mat[i][j];
         scale.SetPoints(hkl, stol2, fobs, sigma, constraints, frac);
-        cudaMemcpy(fcmol, fc.data(), fc.size() * sizeof(float2), cudaMemcpyHostToDevice);
-        cudaMemcpy(fmask, fm.data(), fm.size() * sizeof(float2), cudaMemcpyHostToDevice);
+        // On the stream the fits run on: it is non-blocking, so nothing orders it after the legacy stream.
+        REQUIRE(cudaMemcpyAsync(fcmol, fc.data(), fc.size() * sizeof(float2), cudaMemcpyHostToDevice, stream) ==
+                cudaSuccess);
+        REQUIRE(cudaMemcpyAsync(fmask, fm.data(), fm.size() * sizeof(float2), cudaMemcpyHostToDevice, stream) ==
+                cudaSuccess);
+        REQUIRE(cudaStreamSynchronize(stream) == cudaSuccess);
     }
 };
 
@@ -272,10 +276,12 @@ TEST_CASE("ModelScaleGPU_SolventGridMatchesFitModelScale", "[ModelValidation][gp
         const ModelScaleReport report = FitModelScale(cpu, {}, 8);
         const ModelSolventFit fit = gpu.scale.FitSolvent(gpu.fcmol, gpu.fmask);
         CHECK(fit.n_grid == report.n_grid);
-        CHECK(fit.k_sol == cpu.k_sol);   // the same grid point, so the same double
-        CHECK(fit.b_sol == cpu.b_sol);
+        // The same grid point, so the same doubles - or, on a near-tie another card resolves the other
+        // way, a neighbour whose R is the CPU winner's (checked either way).
+        const bool same_point = fit.k_sol == cpu.k_sol && fit.b_sol == cpu.b_sol;
         CHECK(std::fabs(fit.r - report.r_work_fit) < R_TOLERANCE);
-        CheckSameScale(fit.scale, cpu);
+        if (same_point)
+            CheckSameScale(fit.scale, cpu);
     }
 }
 
@@ -300,10 +306,11 @@ TEST_CASE("ModelScaleGPU_MatchesGemmiOnAModelsPoints", "[ModelValidation][gpu]")
 
             const ModelScaleReport report = FitModelScale(cpu, {}, 4);
             const ModelSolventFit solvent = gpu.scale.FitSolvent(gpu.fcmol, gpu.fmask);
-            CHECK(solvent.k_sol == cpu.k_sol);
-            CHECK(solvent.b_sol == cpu.b_sol);
+            // As above: the same grid point, or a near-tie's neighbour at the CPU winner's R.
+            const bool same_point = solvent.k_sol == cpu.k_sol && solvent.b_sol == cpu.b_sol;
             CHECK(std::fabs(solvent.r - report.r_work_fit) < R_TOLERANCE);
-            CheckSameScale(solvent.scale, cpu);
+            if (same_point)
+                CheckSameScale(solvent.scale, cpu);
 
             gemmi::Scaling<float> ref = cpu;
             ref.fix_k_sol = true;