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)

image_analysis/structure_refinement/ModelScaleGPU.h

@@ -36,6 +36,8 @@ struct ModelScaleFitState {
     double k_sol, b_sol;
     int mode;
     int column;   // the fit's row of |Fcalc + solvent| on the device
+    int weighted; // the robust fit's weights (row `column`) multiply the WSSR and J^T J, J^T r; 0: weight 1
+    double c;     // the robust fit's scale of the residuals (ModelScaling.cpp, RobustReweight)
 };
 
 class ModelScaleGPU {
@@ -59,7 +61,12 @@ public:
     // FitModelScale (ModelScaling.cpp) with the default box, b_sol up to b_hi: the same grid, the same
     // winner. Throws ModelScaleGPUTooFewReflections where FitModelScale would chain the grid points
     // (five or fewer reflections for the isotropic fit).
-    ModelSolventFit FitSolvent(const float2 *d_fcmol, const float2 *d_fmask, double b_hi = 80.0);
+    // robust: the fine pass by robust least squares, as FitModelScale with ModelScaleBox::robust - the
+    // reweighting on the device, the median of each fit's first residuals on the host on `nthreads` threads.
+    ModelSolventFit FitSolvent(const float2 *d_fcmol, const float2 *d_fmask, double b_hi = 80.0,
+                               bool robust = false, size_t nthreads = 1);
+    // What a robust FitSolvent takes on the card beyond DeviceBytes(), reserved at its first call.
+    static size_t RobustBytes(size_t max_points);
 
 private:
     struct LevMarRun;
@@ -72,6 +79,10 @@ private:
     const double *Reduce(int nfits);
     const double *Sums(const std::vector<ModelScaleFitState> &fits);
     void FitBatch(const float2 *d_fcmol, const float2 *d_fmask, std::vector<ModelScaleFitState> &fits);
+    // gemmi's Levenberg-Marquardt for every fit in `fits` from the parameters it holds.
+    void LevMarBatch(std::vector<ModelScaleFitState> &fits);
+    // The robust rounds of a batch FitBatch() has fitted: reweight, fit again, ROBUST_ROUNDS times.
+    void RobustBatch(std::vector<ModelScaleFitState> &fits, size_t nthreads);
 
     cudaStream_t stream_;
     size_t max_points_;
@@ -91,4 +102,6 @@ private:
     CudaDevicePtr<double> sums_;              // per fit, per slot
     CudaHostPtr<ModelScaleFitState> host_fits_;
     CudaHostPtr<double> host_sums_;
+    CudaDevicePtr<float> weight_, residual_;  // the robust fit's, per fit of a batch, per point
+    CudaHostPtr<float> host_residual_;
 };