Stills: re-check the per-image scale after the partiality refine

ScaleOnTheFly's collapsed-scale guard ran, and then StillsPartialityRefine
re-fitted every crystal's scale with no floor and adopted it unconditionally
whenever the image had no prior CC - which is exactly the state the guard leaves
behind. So the guard was protecting almost nothing. Measured on a lysozyme jet
dataset: of 367 images it left unscaled, only 8 were still unscaled in the
output, and 53 reached the merge at or below a fiftieth of the run median, the
worst at a 4525th; on a second run of the same sample, 297 images, worst at a
75000th. Those intensities are what the merge saw - up to 94x too high in the
written file.

Run the guard again on the refined scales. It now reports 367 then 51 on that
dataset, and the merge improves: R-meas 117.4 -> 110.8%, CC1/2 96.3 -> 96.5%.

Measurements confirm the rest of the guard is right as it stands: 0.02 is ~5x
below the lowest scale ever seen on an image that correlates with the merge
(no image at CC >= 0.4 falls below a tenth of the median), and leaving the image
at G = 1 beats both dropping it and replacing its scale with the median - on a
run where 30% of images are affected, dropping costs 1.8 CC1/2 and 29%
multiplicity.

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

rugnux/Rugnux.cpp

@@ -40,6 +40,7 @@
 #include "../image_analysis/lattice_search/LatticeSearch.h"
 #include "../image_analysis/scale_merge/TwinningAnalysis.h"
 #include "../image_analysis/scale_merge/HKLKey.h"
+#include "../image_analysis/scale_merge/ScaleOnTheFly.h"
 #include "../image_analysis/scale_merge/StillsPartialityRefine.h"
 #include "../image_analysis/WriteReflections.h"
 #include "../image_analysis/bragg_integration/CalcISigma.h"
@@ -1127,6 +1128,13 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 StillsPartialityRefine refiner(experiment_);
                 const double mean_tilt = refiner.Run(indexer->GetIntegrationOutcome(), config_.nthreads);
                 logger.Info("Stills partiality post-refine: mean |dpsi| = {:.3f} deg", mean_tilt);
+                // The refine fits its OWN per-image scale, with no floor, and adopts it unconditionally
+                // when the image has no prior CC - which is exactly the state the guard above leaves. So
+                // the guard was protecting nothing: measured on a jet dataset, of 367 images it left
+                // unscaled only 8 were still unscaled in the output, and 53 reached the merge at or below
+                // a fiftieth of the run median, the worst at a 4525th. Whatever produced the final scale,
+                // it is the final scale that has to be credible.
+                ScaleOnTheFly::RejectCollapsedScales(indexer->GetIntegrationOutcome());
             }
             const std::vector<IntegrationOutcome> &merge_input = indexer->GetIntegrationOutcome();