feat(observability): logcat-visible DRED proof of life on Android

Adds enough INFO-level logging that an opus-DRED-v2 APK on Android can
be verified end-to-end by reading logcat alone — no debugger, no
Prometheus, no telemetry pipeline required. Three observation points:

1. Encoder construction (opus_enc.rs)
   - Bumped the "DRED enabled" log from debug! to info! so the
     per-call DRED config is in logcat by default. Each call's first
     OpusEncoder construction logs codec, dred_frames, dred_ms,
     loss_floor_pct.
   - Added a one-shot static OnceLock that logs `opusic_c::version()`
     the first time an OpusEncoder is built in the process. This is
     the smoking gun for "is the new libopus actually loaded" — pre-
     Phase-0 audiopus shipped libopus 1.3 with no DRED, post-Phase-0
     should print 1.5.2 here.

2. DRED state ingest (DredRecvState::ingest_opus in
   desktop/src-tauri/src/engine.rs)
   - First successful parse on a call logs immediately so we can see
     "DRED is on the wire" in logcat.
   - Subsequent parses sample every 100th to confirm steady-state
     samples_available without drowning the log.
   - New parses_total / parses_with_data counters track the parse
     rate vs the success rate (a packet without DRED in it returns
     `available == 0`, so a low ratio means the encoder isn't
     emitting DRED bytes).

3. DRED reconstruction events (DredRecvState::fill_gap_to)
   - Every DRED reconstruction logs at INFO with missing_seq,
     anchor_seq, offset_samples, offset_ms, samples_available,
     gap_size, and the running total. These events are rare on a
     clean network and we want to know exactly which gap was filled.
   - First three classical PLC fills + every 50th thereafter log so
     we can see when DRED couldn't cover a gap (offset out of range,
     no good state, or reconstruct error).

4. Recv heartbeat (Android start() in engine.rs)
   - Existing 2-second heartbeat now includes dred_recv,
     classical_plc, dred_parses_with_data, dred_parses_total
     so a steady-state call shows the cumulative counters in
     logcat without parsing.

How to verify on a real call:

  adb logcat -s 'RustStdoutStderr:*' | grep -i 'dred\|libopus version'

Expected output sequence on a successful Opus call:
  - "linked libopus version libopus_version=libopus 1.5.2-..."  (once per process)
  - "opus encoder: DRED enabled codec=Opus24k dred_frames=20 dred_ms=200 loss_floor_pct=15"  (per call)
  - "DRED state parsed from Opus packet seq=N samples_available=4560 ms=95 ..."  (after first DRED-bearing packet)
  - "recv heartbeat (android) ... dred_recv=0 classical_plc=0 dred_parses_with_data=58 dred_parses_total=58"  (every 2s)

If you see "linked libopus version libopus 1.3" — the FFI swap didn't
take. If dred_parses_with_data stays at 0 while dred_parses_total
climbs — the sender isn't emitting DRED (check the encoder's loss
floor and the receiver's libopus version). If gaps trigger
"classical PLC fill" instead of "DRED reconstruction fired" —
DRED state coverage is too small for the observed loss pattern,
and the loss floor or DRED duration policy needs tuning.

Verification:
- cargo check -p wzp-codec -p wzp-client: 0 errors
- cargo check -p wzp-desktop: 0 Rust errors (only the pre-existing
  tauri::generate_context!() proc macro panic on missing ../dist
  which fires at host check time, irrelevant on the remote build)
- cargo test -p wzp-codec --lib: 69 passing (no regressions)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

crates/wzp-codec/src/opus_enc.rs

@@ -38,10 +38,18 @@
 //! keeping the bitrate overhead modest compared to 25%. Real measurements
 //! from the quality adapter override upward when loss exceeds the floor.
 
+use std::sync::OnceLock;
+
 use opusic_c::{Application, Bitrate, Channels, Encoder, InbandFec, SampleRate, Signal};
-use tracing::{debug, warn};
+use tracing::{debug, info, warn};
 use wzp_proto::{AudioEncoder, CodecError, CodecId, QualityProfile};
 
+/// Logged exactly once per process the first time an OpusEncoder is built.
+/// Confirms that libopus 1.5.2 (the version with DRED) is actually linked
+/// at runtime — invaluable when chasing "is the new codec loaded?"
+/// regressions on Android, where the only debug surface is logcat.
+static LIBOPUS_VERSION_LOGGED: OnceLock<()> = OnceLock::new();
+
 /// Minimum `OPUS_SET_PACKET_LOSS_PERC` value used in DRED mode. libopus
 /// scales the DRED emission window with the assumed loss percentage:
 /// empirically, 5% gives a 15 ms window (useless), 10% gives 55 ms, 15%
@@ -178,7 +186,11 @@ impl OpusEncoder {
             .set_packet_loss(DRED_LOSS_FLOOR_PCT)
             .map_err(|e| CodecError::EncodeFailed(format!("set packet loss floor: {e:?}")))?;
 
-        debug!(
+        // Bumped from debug! to info! so the DRED config is visible in
+        // logcat without enabling debug-level filtering. Each call's
+        // first OpusEncoder construction will log this; subsequent
+        // profile switches log it again with the new tier.
+        info!(
             codec = ?codec,
             dred_frames,
             dred_ms = dred_frames as u32 * 10,
@@ -186,6 +198,14 @@ impl OpusEncoder {
             "opus encoder: DRED enabled"
         );
 
+        // One-shot logging of the linked libopus version so we can
+        // confirm at a glance that opusic-c (libopus 1.5.2) is loaded.
+        // Pre-Phase-0 audiopus shipped libopus 1.3 which has no DRED;
+        // if this log says "libopus 1.3" something is very wrong.
+        LIBOPUS_VERSION_LOGGED.get_or_init(|| {
+            info!(libopus_version = %opusic_c::version(), "linked libopus version");
+        });
+
         Ok(())
     }