bragg_integration: quantization-noise variance floor + summation fallback

The Kabsch profile-fit weights floored the per-pixel variance at 1.0, far
above the real detector noise floor (electronic noise is well below 1 for
both EIGER and JUNGFRAU). The true floor is the quantization noise from
rounding the charge-spread deposited energy to an integer: Var = 1/12. The
1.0 floor silently over-regularized — it inflated weak-reflection sigma ~6x
at high resolution and pinned the scaling error model's `a` term at its 0.25
floor, suppressing ISa.

Use PIXEL_VARIANCE_FLOOR = 1/12, and guard against the weak-reflection
runaways it exposes: fall back to the box-sum (summation) intensity when the
profile fit diverges from the summation seed by more than
PROFILE_SUMMATION_MAX_NSIGMA box-sum sigmas. Applied identically in the CPU
and GPU engines (GPU-vs-CPU equivalence test passes).

Battery of 24 rotation crystals: broad ISa gains (lysoC_14 7.8->10.4, plus
cytC/Ins/Myo), EcwtAL500 completeness 51->92% and CC1/2 35->79%, pding4_001
space group now correct; no space-group regressions.

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

image_analysis/bragg_integration/BraggIntegrationEngineCPU.cpp

@@ -293,7 +293,7 @@ std::vector<Reflection> BraggIntegrationEngineCPU::RunImpl(const Sampler &img,
         }
 
         const int Gf = 2 * Rf + 1;
-        const double B = std::max(rh.bkg, 1.0);
+        const double B = std::max(rh.bkg, PIXEL_VARIANCE_FLOOR);
         double I = rh.I, den = 0.0;
         for (int iter = 0; iter < 4; ++iter) {
             double num = 0.0;
@@ -314,7 +314,16 @@ std::vector<Reflection> BraggIntegrationEngineCPU::RunImpl(const Sampler &img,
         }
         if (!(den > 0.0)) continue;
 
-        results[i] = {static_cast<float>(I), static_cast<float>(std::sqrt(1.0 / den)),
+        // Guard against profile-fit runaways: on a weak / near-zero reflection the reweighted Kabsch
+        // iteration has no real peak to lock onto and can manufacture intensity the box sum never sees.
+        // Keep the profile intensity only if it agrees with the summation seed within the margin;
+        // otherwise fall back to the summation, which is robust there.
+        double sigma = std::sqrt(1.0 / den);
+        if (std::abs(I - rh.I) > PROFILE_SUMMATION_MAX_NSIGMA * rh.sigma) {
+            I = rh.I;
+            sigma = rh.sigma;
+        }
+        results[i] = {static_cast<float>(I), static_cast<float>(sigma),
                       static_cast<float>(rh.bkg), 0.0f, 0.0f, true, false};
     }