Refinement GPU: the robust scale fit on the card, the pool back in every trial slot

The score's robust fine pass (pseudo-Huber IRLS of ModelScaleBox::robust) on the device, so that refinement on
a GPU no longer fits its scale on the host every cycle - with the trials side by side that was a robust grid
search on one thread per slot (13-133 s per refinement on the seven timing sets, against 1.7-8 s before the
score commit).

- ModelScaleGPU: the weights multiply the WSSR and J^T J / J^T r in scale_sums (a weight row per fit,
  reserved at the first robust fit); robust_residuals / robust_weights kernels; the median of each fit's
  first residuals taken on the host as FitModelScale takes it (nth_element at n/2, on the fits' threads);
  LevMarBatch split out of FitBatch so that the rounds restart from where a fit stands. FitSolvent(...,
  robust) refits the coarse winner in the fine pass, as FitModelScale's robust fit does; the plain fit is
  unchanged.
- ModelScaleGPUPool::Fit(..., robust); its streams at the highest priority: a fit is a chain of small
  launches the host waits on, and on a card shared with the trials' long kernels each wait queued behind
  them (refit.scale 58-87 ms -> 14-45 ms per cycle, the result the same to the bit).
- Refinement: the main context and every trial slot fit on their pool (robust); the CPU engine keeps
  FitModelScale's robust fit.

The card's fit is FitModelScale's to rounding (float residuals and weights, the steps' anisotropic factor in
float), deterministic run to run and whichever engine a fit takes: R-work/R-free of the 14 parity sets on
the GPU equal the CPU engine's to 4 digits (largest difference 1.4e-6 on the 3.6 A set).
Test: ModelScaleGPUPool_RobustMatchesFitModelScale (one reflection in fifty a 4x outlier, five cells).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015CeEGgpKdfkCTJb3YNMJcu
(cherry picked from commit d15f048cbd7ed2d6b430f9f9cb5018ca284da8f0)

tests/ModelScaleGPUTest.cpp

@@ -392,6 +392,45 @@ TEST_CASE("ModelScaleGPUPool_MatchesFitModelScale", "[ModelValidation][gpu]") {
     }
 }
 
+// Refinement's robust fit (ModelScaleBox::robust) on the card: the reweighting on the device, the answer
+// FitModelScale's to rounding where one reflection in fifty is a gross outlier - and the same, to the bit, run to
+// run and whichever engine a fit got.
+TEST_CASE("ModelScaleGPUPool_RobustMatchesFitModelScale", "[ModelValidation][gpu]") {
+    if (get_gpu_count() == 0)
+        SKIP("No GPU");
+    for (const Case &c : CASES) {
+        INFO(c.name);
+        gemmi::UnitCell cell(c.a, c.b, c.c, c.alpha, c.beta, c.gamma);
+        const gemmi::SpaceGroup &sg = *gemmi::find_spacegroup_by_name(c.hm);
+        gemmi::Scaling<float> points = MakeScaling(cell, sg, 2.8);
+        for (size_t i = 0; i < points.points.size(); i += 50)
+            points.points[i].fobs *= 4.0f;
+        gemmi::Scaling<float> cpu = points, cpu_plain = points;
+        FitModelScale(cpu, {.robust = true}, 8);
+        FitModelScale(cpu_plain, {}, 8);
+
+        ModelScaleGPUPool pool(0, points.points.size(), 2);
+        std::vector<gemmi::Scaling<float>> gpu(4, points);
+        std::vector<std::future<void>> fits;
+        for (size_t i = 0; i < gpu.size(); i++)
+            fits.push_back(std::async(std::launch::async, [&, i] { pool.Fit(gpu[i], 80.0, 2, true); }));
+        for (auto &f : fits)
+            f.get();
+
+        // the robust answer is not the plain one, and the card's is the host's to rounding
+        CHECK(std::fabs(cpu.k_overall - cpu_plain.k_overall) > 1e-3 * cpu.k_overall);
+        CHECK(gpu[0].k_overall == Catch::Approx(cpu.k_overall).epsilon(1e-3));
+        CHECK(gpu[0].k_sol == Catch::Approx(cpu.k_sol).margin(0.026));
+        CHECK(std::fabs(gpu[0].calculate_r_factor() - cpu.calculate_r_factor()) < 1e-4);
+        for (size_t i = 1; i < gpu.size(); i++) {
+            CHECK(gpu[i].k_sol == gpu[0].k_sol);
+            CHECK(gpu[i].b_sol == gpu[0].b_sol);
+            CHECK(gpu[i].k_overall == gpu[0].k_overall);
+            CHECK(std::memcmp(&gpu[i].b_star, &gpu[0].b_star, sizeof(gpu[0].b_star)) == 0);
+        }
+    }
+}
+
 // ModelScaling fits past a reflection the solvent cancels exactly (ModelScalingTest.cpp), on the card.
 TEST_CASE("ModelScaleGPUPool_FitsPastAReflectionTheSolventCancelsExactly", "[ModelValidation][gpu]") {
     if (get_gpu_count() == 0)