Implement FFT pad-factor caching and the stored-cache display fast path

tests/test_stored_cache.py exercised two features that were never built,
so six of its tests had been failing on main. Both are now implemented.

Pad-factor caching. A padded view could not use a stored FFT cache at all:
the store was pad 1 by definition and cached_rf_image rejected any n_fft
outright, so a user working at a pad factor got nothing from batch-computing
a file. CACH tail v3 records the pad the images were resolved at, cache_file
computes at a requested pad, and the batch actions pass the viewer's own pad
down — while still refusing a store resolved at a different pad, since a
padded FFT interpolates between the natural bins and so resolves genuinely
different peak frequencies. v1/v2 tails read as pad 1 and keep working.

Stored-cache dispatch. _refresh_display only ever consulted this window's
in-session dicts, so after a batch every angle change still queued a worker
and a progress popup for an image already on disk — the exact cost the batch
was run to avoid. It now checks the file's own DC/FFT blocks first, asking
with allow_dc_recompute=False so the GUI thread never touches I/O. When the
stored cache genuinely cannot serve the view, the scan info panel says why
rather than leaving the silent recompute a mystery.

Two bugs surfaced on the way:

- The angle spinbox was wired on editingFinished, which QAbstractSpinBox
  emits only on Return or focus-out — never on a step. Clicking its arrows,
  the ordinary way to walk a scan, moved the number and left the image
  behind. Now valueChanged with keyboard tracking off, which fires on a step
  and once on commit, but not per keystroke mid-typing. Every existing GUI
  test called _on_view_changed() by hand and so could not have caught this;
  two new tests pin it and fail against the old wiring.

- A plain "fft" batch over a file previously cached with fft_rowavg carried
  the old row_avg_n forward, labelling raw images as row-averaged. It now
  writes row_avg_n=0 explicitly.

Verified: 111 passed (was 103 passed / 6 failed), and
tools/check_equivalence.py is byte-identical to the pre-change baseline.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

sras_workers.py

@@ -192,6 +192,10 @@ class BatchCacheWorker(QObject):
     averaging before the FFT — needs *dc_threshold_mv* and a positive
     *row_avg_n*; see ``sras_compute.cache_file``).
 
+    Both FFT modes cache at *pad_factor*, which the caller sets from the
+    viewer's own padding — a cache stored at a pad the user is not viewing
+    at is one the display can never use.
+
     Files are processed one per subprocess: they are fully independent, each
     opens its own memmap and writes only its own bytes, and only path strings
     and scalars cross the process boundary. Emits ``progress(int)`` (0–100 by
@@ -203,13 +207,15 @@ class BatchCacheWorker(QObject):
     finished = pyqtSignal()
 
     def __init__(self, paths: list[str], mode: str, apply_bg_sub: bool,
-                dc_threshold_mv: float | None = None, row_avg_n: int = 0):
+                dc_threshold_mv: float | None = None, row_avg_n: int = 0,
+                pad_factor: int = 1):
         super().__init__()
         self._paths = paths
         self._mode = mode
         self._apply_bg_sub = apply_bg_sub
         self._dc_threshold = dc_threshold_mv
         self._row_avg_n = row_avg_n
+        self._pad_factor = pad_factor
 
     def _report(self, path: str, err: str, done: int, total: int):
         self.file_done.emit(path, err)
@@ -235,6 +241,7 @@ class BatchCacheWorker(QObject):
             futures = {
                 executor.submit(cache_file, p, self._mode, self._apply_bg_sub,
                                 compute.get_fft_backend(), per_proc_workers,
+                                pad_factor=self._pad_factor,
                                 dc_threshold_mv=self._dc_threshold,
                                 row_avg_n=self._row_avg_n): p
                 for p in paths
@@ -261,6 +268,7 @@ class BatchCacheWorker(QObject):
                 err = cache_file(path, self._mode, self._apply_bg_sub,
                                  compute.get_fft_backend(),
                                  compute.default_max_workers(),
+                                 pad_factor=self._pad_factor,
                                  dc_threshold_mv=self._dc_threshold,
                                  row_avg_n=self._row_avg_n)
             except Exception as exc: