Bragg prediction: derive the lattice walk from the cell, and expose it in the API

Follow-up to making max_hkl a setting: it is now an optional, and unset means "take
it from this crystal". The predictor keeps only |q| <= 1/d_min and h = a.q for the
real-space axis a, so |h| <= a/d_min exactly - and likewise |k| <= b/d_min and
|l| <= c/d_min. max(a,b,c)/d_min therefore bounds all three at once: nothing that
could be predicted lies outside it, and nothing inside it is reached by a shorter
axis. It applies to rotation and stills alike, both going through the one place the
prediction settings are built.

Offline (rugnux, viewer) the default is unset, so every crystal gets its own range;
--max-hkl overrides it. Online the broker holds a concrete number, because the cost
is the cube of it per image and a live acquisition should not have its frame rate
decided by whichever sample is mounted: max_hkl joins bragg_integration_settings in
the OpenAPI with a default of 100, so an omitted field arrives as that default (the
generated model carries it) rather than as "derive it", and the frontend exposes it
next to the integration model.

Measured against a fixed 100 on six rotation crystals: three are bit-identical, two
were being truncated and recover 419k and 5.8k observations with the high-shell
CC1/2 going 15.1 -> 25.8% and 52.1 -> 55.3%, and the space group is unchanged 6/6.
It reproduces a fixed 200 exactly, which is the bound being tight rather than merely
safe.

The sixth is worth recording: a 149/83/226 A cell derives 227, and because a single
scalar has to cover the longest axis the cube is ~16x what a per-axis box would be -
22% wall clock, for a net 22 observations out of 364k (the per-frame 65536-reflection
cap re-selects at the margin when more candidates are offered) and identical CC1/2,
ISa and space group. Per-axis limits would remove that; the predictors already map a
thread index to h, k and l separately.

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

common/BraggIntegrationSettings.cpp

@@ -109,15 +109,17 @@ float BraggIntegrationSettings::GetBackgroundTrimFraction() const {
     return bkg_trim_fraction;
 }
 
-BraggIntegrationSettings &BraggIntegrationSettings::MaxHKL(int input) {
-    check_min("Maximum hkl index", input, 1);
-    // The GPU predictor launches one thread per candidate, so the cost is (2n+1)^3: 511 is 1.1e9
-    // candidates per frame, already far past the point where prediction dominates a run.
-    check_max("Maximum hkl index", input, 511);
+BraggIntegrationSettings &BraggIntegrationSettings::MaxHKL(std::optional<int> input) {
+    if (input) {
+        check_min("Maximum hkl index", *input, 1);
+        // The GPU predictor launches one thread per candidate, so the cost is (2n+1)^3: 511 is 1.1e9
+        // candidates per frame, already far past the point where prediction dominates a run.
+        check_max("Maximum hkl index", *input, 511);
+    }
     max_hkl = input;
     return *this;
 }
 
-int BraggIntegrationSettings::GetMaxHKL() const {
+std::optional<int> BraggIntegrationSettings::GetMaxHKL() const {
     return max_hkl;
 }