Replace zoom FFT peak search with a budget-bounded PyFFTW direct transform

Drop the coarse+fine zoom refinement, the SciPy FFT backend, and the
exact= audit path in favor of a single always-on full-transform peak
search (_peak_bins). Block size is now derived from a per-thread memory
budget (_fft_block_for/SRAS_FFT_PLAN_BUDGET_MB) instead of a fixed
constant, so the existing block-parallel PyFFTW pool stays memory-safe
at high pad factors without the zoom algorithm's bookkeeping. Also
removes the now-unused threadpoolctl dependency and the FFT backend
selector from the UI.

Also includes a pre-existing min_freq_mhz peak-search floor (excludes
bins below a caller-supplied frequency from the argmax) that was
already implemented and tested in the working tree.

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

sras_workers.py

@@ -115,7 +115,8 @@ class ComputeWorker(CancellableWorker):
                  apply_bg_sub: bool = True, n_fft: int | None = None,
                  dc_threshold_mv: float = 0.0,
                  dc4_mv: np.ndarray | None = None,
-                 is_fft_mode: bool = False):
+                 is_fft_mode: bool = False,
+                 min_freq_mhz: float = 0.0):
         super().__init__()
         self._sras = sras
         self._angle = angle_idx
@@ -125,6 +126,7 @@ class ComputeWorker(CancellableWorker):
         self._dc_threshold = dc_threshold_mv
         self._dc4_mv = dc4_mv
         self._is_fft_mode = is_fft_mode
+        self._min_freq_mhz = min_freq_mhz
 
     def run(self):
         try:
@@ -132,7 +134,8 @@ class ComputeWorker(CancellableWorker):
                 img = compute_rf_image(
                     self._sras, self._angle, dc_threshold_mv=self._dc_threshold,
                     apply_bg_sub=self._apply_bg_sub, n_fft=self._n_fft,
-                    dc4_mv=self._dc4_mv, should_stop=self._stopped)
+                    dc4_mv=self._dc4_mv, should_stop=self._stopped,
+                    min_freq_mhz=self._min_freq_mhz)
             else:
                 img = dc_image_mv(self._sras, self._angle, self._ch,
                                   should_stop=self._stopped)
@@ -240,7 +243,7 @@ class BatchCacheWorker(QObject):
         with ProcessPoolExecutor(max_workers=n_procs) as executor:
             futures = {
                 executor.submit(cache_file, p, self._mode, self._apply_bg_sub,
-                                compute.get_fft_backend(), per_proc_workers,
+                                per_proc_workers,
                                 pad_factor=self._pad_factor,
                                 dc_threshold_mv=self._dc_threshold,
                                 row_avg_n=self._row_avg_n): p
@@ -266,7 +269,6 @@ class BatchCacheWorker(QObject):
         for path in paths:
             try:
                 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,