rugnux: parallelise candidate-cell refinement, and stop repeating work in the tail

Three independent changes to the CPU-bound parts of an offline rotation run, none
of which alters a result.

Candidate-cell refinement now splits across threads. RefineCandidateCells already
took a (block, nblocks) partition, but the only call site passed nblocks=1, so the
whole first pass of a two-pass rotation run sat on one thread per scheme - two
threads, unchanged at every -N, for a third of the run. A block touches only its
own scores(j) and cells rows and holds its own scratch, so the split is exact.
The budget is a new IndexingSettings::RefineThreads, left at 1 by default and set
only where few indexer threads exist: raising it unconditionally would
oversubscribe the paths that already run one indexer per image across all workers.

The mmCIF writer built a std::ostringstream per formatted number, twelve per
reflection. snprintf gives the same digits for 0.535 -> 0.220 s per file.

The space-group search built the same orbit mapping twice per candidate point
group - once for the merge chi^2 and once for the systematic-error b, an
apply_to_hkl and Canonicalize per observation per operator each time. Build it
once and hand it to both.

18 Mpx rotation set 24.6 -> 18.7 s, 2.5 Mpx 13.0 -> 10.7 s, and the 37-crystal
battery 13m55s -> 10m47s with no failures, the same 34/37 space groups, and
statistics unchanged on 30 of 37 (the rest drift within the run-to-run spread the
binary already had, which a control build with the split disabled reproduces).

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

image_analysis/WriteReflections.cpp

@@ -8,6 +8,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <cstdio>
 #include <map>
 #include <tuple>
 #include <fstream>
@@ -39,12 +40,15 @@ std::string CurrentDateISO() {
 }
 
 /// Format a double with given decimal places; returns "?" for non-finite.
+/// snprintf rather than an ostringstream: the reflection loop below calls this twelve times per
+/// reflection, and building a stream (and its locale) per call dominated the time spent writing a
+/// merged file. Same digits - both go through the C locale's %.*f.
 std::string Fmt(double val, int decimals = 4) {
     if (!std::isfinite(val))
         return "?";
-    std::ostringstream ss;
-    ss << std::fixed << std::setprecision(decimals) << val;
-    return ss.str();
+    char buf[512];
+    const int n = std::snprintf(buf, sizeof(buf), "%.*f", decimals, val);
+    return std::string(buf, n);
 }
 
 /// Quote a CIF string value; returns "?" for empty.