feat(cw): draw the whole audio band so an out-of-window tone is visible

The waterfall showed only the model's 400-1200 Hz window, so a tone outside it
was absent from the picture entirely. Measured on keyed audio, the brightest
column in that narrow view swings 1.01x between key-down and key-up against
13.76x for a tone in range - it carries no keying at all, so the operator could
not tell a signal was present, let alone where it was. Markers alone could not
fix that: they pointed at a frequency with nothing drawn there.

compute() now takes an optional bin range, defaulting to the model's own, so the
decoder path is byte-identical and the golden-vector test still holds. The
display asks for DC to Nyquist, 129 bins against 65. The FFT already computed
every bin - this only changes which are kept - so the cost is a wider copy.

The decoder window is framed and faintly lifted, since half the picture is now
outside what the model reads and nothing said which half.

Marker fixes found while reviewing the render: the tone marker was orange, which
is a colour the inferno ramp itself passes through, so a marker sitting on the
trace it pointed at was indistinguishable from the keying gaps in that trace -
invisible in exactly the case it existed for. It is cyan now, and both markers
are pips in a gutter above the spectrum rather than lines across it.

Also from the release audit:

- compute()'s bin-count guard was written as a three-term disjunction, which any
  custom range satisfies regardless of bin count, leaving the model invariant
  unenforced for the caller most able to break it. Rewritten as an implication,
  with a Nyquist bound so no range can index past the FFT output.
- signalStrength was gated on a confirmed out-of-window tone, which is false when
  detection fails - and it fails for a slow fist, measured at prominence 2.5
  against a 4.5 threshold for 15% duty. So the meter still read half scale beside
  an empty transcript. It now requires a tone confirmed decodable: 11 flow
  combinations, 3 wrong before, 0 wrong after.
- detectedToneHz never expired, so after retuning into the band the hint kept
  naming the frequency the operator had left, indefinitely. It now clears after
  10 s without a tone, which is clear of any real gap - the longest being 1.7 s
  between words at 5 WPM.
- The waterfall label read estimatedPitch while the hint read detectedToneHz, two
  numbers up to 800 Hz apart both claiming to be the tone. Both read the latter.
- Removed a redundant toFloat() that the compiler warned about.

Accessibility, untouched until now: the waterfall was a bare Canvas and the AMSAT
day cells bare Boxes, so both announced nothing at all - on the status page that
is the entire content of the screen. Both now carry a contentDescription naming
the tone or the day's worst status and report count. The AMSAT tap target goes
from 28 dp to 48 dp with the coloured tile still 28 dp, so the grid keeps its
density. Strings in all nine locales for both modules.

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwDeepSpectrogram.kt

@@ -62,6 +62,20 @@ object CwDeepSpectrogram {
     /** Number of frequency bins the model expects. */
     const val FREQUENCY_BINS = 65
 
+    /**
+     * Widest span worth displaying: DC to Nyquist.
+     *
+     * The model reads [MIN_FREQ_HZ]..[MAX_FREQ_HZ], but a tone outside that range leaves
+     * no trace inside it - measured on keyed audio, the brightest column in the narrow
+     * view swings 1.01x between key-down and key-up, against 13.76x for a tone the model
+     * can see. So the narrow view cannot even show that a signal exists, and the display
+     * spans the whole band instead. Nothing above Nyquist can be shown at all: it aliases.
+     */
+    const val DISPLAY_MIN_FREQ_HZ = 0.0
+
+    /** Upper end of the display span; see [DISPLAY_MIN_FREQ_HZ]. */
+    const val DISPLAY_MAX_FREQ_HZ = SAMPLE_RATE / 2.0
+
     /** Milliseconds of audio represented by one output frame. */
     const val MS_PER_FRAME = 1000.0 * HOP_LENGTH / SAMPLE_RATE
 
@@ -111,17 +125,30 @@ object CwDeepSpectrogram {
      *
      * @return `[frames][FREQUENCY_BINS]` values, all non-negative.
      */
-    fun compute(audio: FloatArray): Array<FloatArray> {
+    fun compute(
+        audio: FloatArray,
+        minHz: Double = MIN_FREQ_HZ,
+        maxHz: Double = MAX_FREQ_HZ
+    ): Array<FloatArray> {
         require(audio.size >= FFT_LENGTH) {
             "audio is too short for fftLength=$FFT_LENGTH, got ${audio.size}"
         }
 
-        val (startBin, stopBin) = frequencyBinRange(
-            SAMPLE_RATE, FFT_LENGTH, MIN_FREQ_HZ, MAX_FREQ_HZ
-        )
+        val (startBin, stopBin) = frequencyBinRange(SAMPLE_RATE, FFT_LENGTH, minHz, maxHz)
         val bins = stopBin - startBin
-        require(bins == FREQUENCY_BINS) {
-            "expected $FREQUENCY_BINS bins, computed $bins"
+        require(bins > 0) { "empty bin range for $minHz..${maxHz}Hz" }
+        // The model's range must yield exactly the bin count it was trained on. Written as
+        // an implication rather than a disjunction of all three terms: `a != x || b != y ||
+        // bins == n` is satisfied by any custom range regardless of the bin count, which
+        // would leave the invariant unenforced for the caller most likely to break it.
+        val isModelRange = minHz == MIN_FREQ_HZ && maxHz == MAX_FREQ_HZ
+        require(!isModelRange || bins == FREQUENCY_BINS) {
+            "expected $FREQUENCY_BINS bins for the model range, computed $bins"
+        }
+        // Nothing may run off the end of the FFT output: a real signal has FFT_LENGTH / 2
+        // + 1 distinct bins, and asking beyond Nyquist would index past them.
+        require(stopBin <= FFT_LENGTH / 2 + 1) {
+            "maxHz ${maxHz}Hz is above Nyquist ${SAMPLE_RATE / 2}Hz"
         }
 
         val padded = reflectPad(audio, FFT_LENGTH / 2)

core/domain/src/test/java/com/rtbishop/look4sat/core/domain/cw/CwDeepSpectrogramTest.kt

@@ -17,6 +17,7 @@
  */
 package com.rtbishop.look4sat.core.domain.cw
 
+import org.junit.Assert.assertArrayEquals
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Test
@@ -61,6 +62,46 @@ class CwDeepSpectrogramTest {
         assertTrue("peak at index $peak, expected near 24", abs(peak - 24) <= 1)
     }
 
+    /**
+     * The waterfall asks for the whole band so that a tone the model cannot read is still
+     * in the picture. Inside the model's window such a tone leaves nothing to see: the
+     * brightest column there is noise, and it does not even follow the keying.
+     */
+    @Test
+    fun compute_wholeBandPlacesAnOutOfWindowTone() {
+        val audio = FloatArray(3200) { (0.6 * sin(2.0 * PI * 1500.0 * it / 3200.0)).toFloat() }
+        val display = CwDeepSpectrogram.compute(
+            audio,
+            CwDeepSpectrogram.DISPLAY_MIN_FREQ_HZ,
+            CwDeepSpectrogram.DISPLAY_MAX_FREQ_HZ
+        )
+        // DC to Nyquist inclusive: 0..1600 Hz in 12.5 Hz steps.
+        assertEquals(129, display[0].size)
+
+        val middle = display[display.size / 2]
+        val peak = middle.indices.maxByOrNull { middle[it] } ?: -1
+        val binHz = CwDeepSpectrogram.SAMPLE_RATE.toDouble() / CwDeepSpectrogram.FFT_LENGTH
+        assertEquals("1500 Hz must land on its own bin", 1500.0, peak * binHz, binHz)
+    }
+
+    /** The model's own call must keep its exact shape, whatever the display asks for. */
+    @Test
+    fun compute_defaultsToTheModelWindow() {
+        val audio = FloatArray(3200) { (0.6 * sin(2.0 * PI * 700.0 * it / 3200.0)).toFloat() }
+        val model = CwDeepSpectrogram.compute(audio)
+        val explicit = CwDeepSpectrogram.compute(
+            audio, CwDeepSpectrogram.MIN_FREQ_HZ, CwDeepSpectrogram.MAX_FREQ_HZ
+        )
+        assertEquals(CwDeepSpectrogram.FREQUENCY_BINS, model[0].size)
+        assertEquals(model.size, explicit.size)
+        for (frame in model.indices) {
+            assertArrayEquals(
+                "explicit model range must equal the default",
+                model[frame], explicit[frame], 0f
+            )
+        }
+    }
+
     @Test
     fun compute_appliesLog1pSoValuesAreNonNegative() {
         val audio = FloatArray(3200) { (0.6 * sin(2.0 * PI * 700.0 * it / 3200.0)).toFloat() }