feat(02-01): implement synth config, oscillator, and layer

- synth/config.go: FreqConfig, HarmonicDef types; ClassFreqConfigs for all 11 traffic classes
  with frequencies in 60-800 Hz using musical intervals; pan positions per D-12
- synth/oscillator.go: phase-accumulator oscillator with additive harmonic synthesis
  and phase subtraction wrap (not math.Mod) per D-05
- synth/layer.go: EMA amplitude smoothing with tau-based alpha; whisper floor (0.03)
  prevents silence once class has been seen; UpdateTarget/AdvanceSample interface
- All 12 tests pass (TestAllClassesHaveConfig, TestFrequenciesUnique, TestEMAAmplitudeRise, etc.)

synth/layer.go

@@ -0,0 +1,70 @@
+package synth
+
+import "math"
+
+// EMAAlpha computes the per-sample smoothing coefficient for a given time constant.
+// tau=1.0 at SR=44100 gives alpha ~0.0000227 (63% of target reached in 1 second). Per D-07.
+func EMAAlpha(tau float64, sampleRate int) float64 {
+	return 1.0 - math.Exp(-1.0/(tau*float64(sampleRate)))
+}
+
+// Layer combines an oscillator with EMA amplitude smoothing for one traffic class.
+type Layer struct {
+	Config     FreqConfig
+	Osc        *Oscillator
+	currentAmp float64
+	targetAmp  float64
+	alpha      float64 // EMA coefficient
+	seen       bool    // whether this class has ever had count > 0
+	whisper    float64 // whisper floor amplitude (D-08)
+}
+
+// NewLayer creates a Layer for the given config using the specified sample rate and EMA time constant (tau in seconds).
+func NewLayer(cfg FreqConfig, sampleRate int, tau float64) *Layer {
+	return &Layer{
+		Config:  cfg,
+		Osc:     NewOscillator(cfg.BaseHz, sampleRate),
+		alpha:   EMAAlpha(tau, sampleRate),
+		whisper: WhisperFloor,
+	}
+}
+
+// UpdateTarget sets the target amplitude from a packet count and max count across all classes.
+// Per D-07/D-08/D-09: once seen, floor is whisper; amplitude scales linearly with normalized rate.
+func (l *Layer) UpdateTarget(count int64, maxCount int64) {
+	if count > 0 {
+		l.seen = true
+	}
+	if !l.seen {
+		l.targetAmp = 0.0
+		return
+	}
+	normalizedRate := 0.0
+	if maxCount > 0 {
+		normalizedRate = float64(count) / float64(maxCount)
+	}
+	l.targetAmp = l.whisper + (1.0-l.whisper)*normalizedRate
+}
+
+// AdvanceSample renders one sample and advances the EMA amplitude toward target.
+// Returns the raw mono sample (before pan/gain).
+func (l *Layer) AdvanceSample() float64 {
+	sample := l.Osc.Advance(l.Config.Harmonics)
+	l.currentAmp += l.alpha * (l.targetAmp - l.currentAmp)
+	return sample * l.currentAmp
+}
+
+// CurrentAmp returns the current amplitude (for testing).
+func (l *Layer) CurrentAmp() float64 {
+	return l.currentAmp
+}
+
+// TargetAmp returns the target amplitude (for testing).
+func (l *Layer) TargetAmp() float64 {
+	return l.targetAmp
+}
+
+// Seen returns whether this layer has ever received traffic (for testing).
+func (l *Layer) Seen() bool {
+	return l.seen
+}