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/indexing/PostIndexingRefinement.cpp

@@ -5,6 +5,7 @@
 #include "PostIndexingRefinement.h"
 
 #include <iostream>
+#include <thread>
 
 namespace {
     struct config_ifssr final {
@@ -145,7 +146,25 @@ std::vector<CrystalLattice> Refine(const std::vector<Coord> &in_spots,
         .min_spots = static_cast<uint32_t>(p.viable_cell_min_spots)
     };
 
-    RefineCandidateCells(spots.topRows(nspots), oCell, scores, cifssr);
+    // Candidate cells refine independently - a block touches only its own scores(j) and cells rows, and
+    // holds its own scratch - so splitting them across threads gives the same numbers as one thread.
+    // Only worth it where few indexer threads run (the rotation first pass uses two, one per scheme,
+    // and leaves the rest of the machine idle); refine_threads stays 1 everywhere else.
+    const unsigned ncells = static_cast<unsigned>(scores.rows());
+    const unsigned nblocks = std::max(1u, std::min(p.refine_threads, ncells));
+    if (nblocks == 1) {
+        RefineCandidateCells(spots.topRows(nspots), oCell, scores, cifssr);
+    } else {
+        std::vector<std::thread> workers;
+        workers.reserve(nblocks - 1);
+        for (unsigned b = 1; b < nblocks; b++)
+            workers.emplace_back([&, b] {
+                RefineCandidateCells(spots.topRows(nspots), oCell, scores, cifssr, b, nblocks);
+            });
+        RefineCandidateCells(spots.topRows(nspots), oCell, scores, cifssr, 0, nblocks);
+        for (auto &w : workers)
+            w.join();
+    }
 
     std::vector<RefinedCandidate> candidates;