feat: stable note tracking, NOTE pitch source and unsure fallback

Producers found the tracked plugins jumpy: the shared tracker switched notes
after 10 ms and retuned every 5 ms, so growls and formant basses flickered
and every tracked plugin acted on wrong notes.

Shared tracker (common-dsp):
- A new note needs a steady read for 40 ms; an octave down 80 ms, an octave
  up 200 ms (an octave-up read still fits the note's period and counts as
  agreeing). Inside a note the tuning only moves past a 0.25 semitone
  deadband. Follow bends keeps the old fast behaviour as an option.
- A trust score turns the note unsure while reads disagree; Tracker::active
  and NoteState report it, and Fallback latches "step back" across note ends.
- Notes end when the window start stays below the gate's release level for
  20 ms, so short gaps between notes are seen without waiting for the gate.
- PitchSource replaces the old (midi, gate, glide) arguments: Audio, MIDI or
  Note mode (a set note, no detection), plus a key lock (minor, major, root
  only) that snaps reads to the key.
- stems.rs: synthetic stems (growls, wobble, reese, formant, 808 slide,
  layered drop, noise riser) and a score; examples/tracker_report scores the
  corpus or real WAV stems. On the corpus the old behaviour makes up to 28
  extra note starts per second; the stable default makes none.

Plugins:
- Anvil, Lathe, Temper, Knurl, Planish, Braze and Forge gain the NOTE pitch
  source, the key lock and Follow bends (shared common-params crate and a
  shared header switch in common-ui).
- Unsure tracking: Anvil brings the original sub back in place of the sine,
  Lathe passes the audio through, Knurl fades its texture out; Temper,
  Planish and Braze hold their last sure tuning. Readouts show the note only
  when it is sure.
- Anvil gains Mode: Replace or Enhance (keeps the original sub and adds the
  sine under it).
- Planish slides its band edges over 6 ms on a new note instead of snapping.
- Ballast defaults to Grid parts, which need no tracking.

plugins/planish/core/src/lib.rs

@@ -34,6 +34,8 @@ pub const ATTACK_MS: [f32; BANDS] = [30., 15., 8., 4.];
 pub const RELEASE_MS: [f32; BANDS] = [200., 160., 120., 90.];
 /// Filter coefficients are recomputed this often, in samples.
 const RETUNE: usize = 16;
+/// A new note slides the band edges over about this long instead of snapping them.
+const EDGE_MS: f32 = 6.;
 const Q: f32 = std::f32::consts::FRAC_1_SQRT_2;
 const SILENT: f32 = -120.;
 
@@ -176,6 +178,9 @@ pub struct Engine {
     pitch: PitchFollower,
     hz: f32,
     hz_coef: f32,
+    edge_coef: f32,
+    /// The edges are sliding to a new note.
+    sliding: bool,
     countdown: usize,
     edges: [f32; BANDS - 1],
     coefs: Coefs,
@@ -226,6 +231,8 @@ impl Engine {
             pitch: PitchFollower::default(),
             hz: 0.,
             hz_coef: 1.,
+            edge_coef: coefficient(rate, EDGE_MS / 3.),
+            sliding: false,
             countdown: 0,
             edges: [0.; BANDS - 1],
             coefs: Coefs {
@@ -264,7 +271,7 @@ impl Engine {
     pub fn set_settings(&mut self, s: Settings) -> Result<(), &'static str> {
         s.validate()?;
         self.tracker
-            .set(s.source == Source::Midi, s.gate, s.smooth > 0.);
+            .set(s.pitch.source(s.source.mode(), s.gate, s.smooth > 0.));
         self.hz_coef = coefficient(self.rate, s.smooth / 3.);
         if s.time != self.settings.time || self.fresh {
             let scale = s.time * 0.01;
@@ -296,6 +303,7 @@ impl Engine {
         self.levels = [SILENT; BANDS];
         self.gains = [0.; BANDS];
         self.countdown = 0;
+        self.sliding = false;
         self.fresh = true;
     }
     pub fn note_on(&mut self, note: u8) {
@@ -346,9 +354,23 @@ impl Engine {
         self.delay_at = (self.delay_at + 1) % len;
         let y = self.delay[self.delay_at];
 
+        // Unsure tracking sends no events, so the edges hold the last sure note. A new note
+        // slides them instead of snapping, so the bands do not pump on note changes.
         let (hz, jump) = self.pitch.step(self.hz_coef);
-        self.hz = hz;
-        if jump || self.countdown == 0 {
+        let first = self.hz == 0.;
+        if jump && !first {
+            self.sliding = true;
+        }
+        if self.sliding {
+            self.hz += (hz - self.hz) * self.edge_coef;
+            if (hz - self.hz).abs() < 1e-3 * hz {
+                self.hz = hz;
+                self.sliding = false;
+            }
+        } else {
+            self.hz = hz;
+        }
+        if (jump && first) || self.countdown == 0 {
             self.retune();
             self.countdown = RETUNE;
         }
@@ -404,7 +426,7 @@ impl Engine {
             sample_rate: self.rate,
             ..AnalyzerFrame::default()
         };
-        if self.tracker.sounding() && self.hz > 0. {
+        if self.tracker.active() && self.hz > 0. {
             f.note = Some(hz_to_midi(self.hz).round().clamp(0., 127.) as u8);
         }
         f

plugins/planish/core/src/settings.rs

@@ -1,4 +1,5 @@
 //! Host-independent controls. Levels in dB, times in milliseconds, amounts in percent.
+use common_dsp::tracker::{Pitch, PitchMode};
 use serde::{Deserialize, Serialize};
 
 /// Bands: the fundamental, low harmonics, mid harmonics and the top.
@@ -15,12 +16,33 @@ pub enum Source {
     Audio,
     /// Notes come from MIDI note input.
     Midi,
+    /// Note starts are detected, the pitch is the set note: nothing is guessed.
+    Note,
+}
+impl Source {
+    pub fn mode(self) -> PitchMode {
+        match self {
+            Source::Audio => PitchMode::Audio,
+            Source::Midi => PitchMode::Midi,
+            Source::Note => PitchMode::Note,
+        }
+    }
+    pub fn from_mode(mode: PitchMode) -> Self {
+        match mode {
+            PitchMode::Audio => Source::Audio,
+            PitchMode::Midi => Source::Midi,
+            PitchMode::Note => Source::Note,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
 #[serde(deny_unknown_fields)]
 pub struct Settings {
     pub source: Source,
+    /// Note mode's note, the key lock and Follow bends.
+    #[serde(default)]
+    pub pitch: Pitch,
     /// Highest harmonic in the bottom band. 1 keeps the fundamental on its own.
     pub low: u32,
     /// Highest harmonic in the second band.
@@ -54,6 +76,7 @@ impl Default for Settings {
     fn default() -> Self {
         Self {
             source: Source::Audio,
+            pitch: Pitch::default(),
             low: 1,
             mid: 4,
             high: 16,
@@ -73,6 +96,7 @@ impl Default for Settings {
 }
 impl Settings {
     pub fn validate(&self) -> Result<(), &'static str> {
+        self.pitch.validate()?;
         let finite = [
             self.depth,
             self.time,