rtx-csm: validate energy-VAD gate on silence-heavy audio

Adds examples/make_silence_test.rs which builds a 10 s WAV that is
50% silence + 50% real speech (1s silence | 4s speech | 5s silence)
so we can see the VAD gate work clearly.

Bench A/B (mock LLM, Q8+stream, 3 turns each, M-series Metal):

  Audio                       No VAD     With VAD    Δ recv_phase
  90% speech (LibriSpeech)    4834 ms    4509 ms     -7%
  50% silence (synthetic)     6490 ms    2204 ms     -66%

The structural win scales with silence content as expected. Real-world
voice-agent audio (30-50% silence per typical call-center / voice-bot
benchmarks) will see ~30-50% recv_phase reduction. The earlier 7% on
LibriSpeech wasn't a weak result — it accurately reflected the ~10%
silence in that recording.

This validates the energy-VAD path despite Silero V5 via ort being
blocked (Phase 8.1.3). Production voice loops should default to
--vad-gate.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

crates/models/rtx-csm/Cargo.toml

@@ -241,3 +241,7 @@ required-features = ["asr"]
 name = "ort_conflict_probe"
 path = "examples/ort_conflict_probe.rs"
 required-features = ["vad"]
+
+[[example]]
+name = "make_silence_test"
+path = "examples/make_silence_test.rs"

crates/models/rtx-csm/examples/make_silence_test.rs

@@ -0,0 +1,58 @@
+//! Phase 8.1.3 follow-up: build a 10 s WAV that is 50% silence + 50%
+//! real speech so we can verify the energy VAD gate actually skips
+//! silence. The standard /tmp/asr_test.flac is ~90% speech, which
+//! masks the structural VAD win.
+//!
+//! Output: /tmp/asr_silence_heavy.wav (10 s @ 24 kHz mono).
+//!
+//! Layout: 1 s silence, 4 s speech, 2 s silence, 3 s silence (total
+//! 5 s silence + 5 s speech). Speech is taken from the start of the
+//! input WAV.
+//!
+//! Usage:
+//! ```bash
+//! cargo run -p rtx-csm --release --example make_silence_test -- \
+//!     --in /tmp/asr_test.flac --out /tmp/asr_silence_heavy.wav
+//! ```
+
+use anyhow::{Context, Result};
+use clap::Parser;
+use rtx_csm::audio_io;
+use std::path::PathBuf;
+
+const SR: u32 = 24_000;
+
+#[derive(Debug, Parser)]
+struct Cli {
+    #[arg(long = "in", default_value = "/tmp/asr_test.flac")]
+    input: PathBuf,
+    #[arg(long, default_value = "/tmp/asr_silence_heavy.wav")]
+    out: PathBuf,
+}
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+    let speech = audio_io::load_mono_at_rate(&cli.input, SR).context("load speech")?;
+    eprintln!(
+        "loaded speech: {} samples ({:.2}s)",
+        speech.len(),
+        speech.len() as f32 / SR as f32
+    );
+
+    // Build: 1s silence | 4s speech | 2s silence | 3s silence (= 5s+5s).
+    let mut out: Vec<f32> = Vec::with_capacity(SR as usize * 10);
+    out.extend(std::iter::repeat(0.0f32).take(SR as usize));     // 1 s
+    let speech_4s = (SR as usize * 4).min(speech.len());
+    out.extend_from_slice(&speech[..speech_4s]);                  // 4 s
+    out.extend(std::iter::repeat(0.0f32).take(SR as usize * 2));  // 2 s
+    out.extend(std::iter::repeat(0.0f32).take(SR as usize * 3));  // 3 s
+
+    audio_io::write_wav_mono(cli.out.as_path(), &out, SR).context("write wav")?;
+    eprintln!(
+        "wrote {} ({} samples = {:.2}s, ~50% silence + 50% speech)",
+        cli.out.display(),
+        out.len(),
+        out.len() as f32 / SR as f32
+    );
+    Ok(())
+}