feat(rvcsi): real nexmon_csi UDP/PCAP fidelity — chanspec decode, libpcap reader, NexmonPcapAdapter

Raises the Nexmon path from a normalized record format to parsing what the
patched Broadcom firmware actually emits, end to end.

napi-c shim (ABI 1.0 -> 1.1, additive):
- rvcsi_nx_csi_udp_header / rvcsi_nx_csi_udp_decode — parse the real nexmon_csi
  UDP payload: the 18-byte header (magic 0x1111, rssi int8, fctl, src_mac[6],
  seq_cnt, core/spatial-stream, Broadcom chanspec, chip_ver) + nsub complex CSI
  samples (modern int16 LE I/Q export — what CSIKit/csireader.py read for the
  BCM43455c0 / 4358 / 4366c0; nsub = (len-18)/4). rvcsi_nx_csi_udp_write to
  synthesize payloads for tests. rvcsi_nx_decode_chanspec — d11ac chanspec ->
  channel (chanspec & 0xff) / bandwidth (bits [13:11], cross-checked against the
  FFT size) / band (bits [15:14], cross-checked against the channel number).
  Still allocation-free, bounds-checked, structured errors, never panics.
- ffi.rs wraps it: decode_chanspec / parse_nexmon_udp_header / decode_nexmon_udp
  / encode_nexmon_udp + DecodedChanspec / NexmonCsiHeader; every unsafe block
  documented; the ABI guard now expects 1.1.

rvcsi-adapter-nexmon:
- pcap.rs — a dependency-free classic-libpcap reader (all four byte-order /
  timestamp-resolution magics; Ethernet / raw-IPv4 / Linux-SLL link types;
  tolerates a truncated final record; pcapng is a follow-up) + extract_udp_payload
  + a synthetic_udp_pcap / synthetic_nexmon_pcap test/example generator.
- NexmonPcapAdapter (a CsiSource) — reads the CSI UDP packets out of a
  `tcpdump -i wlan0 dst port 5500 -w csi.pcap` capture, decodes each via the C
  shim, stamps the frame timestamp from the pcap packet time; non-CSI packets
  counted as "skipped" in health.

rvcsi-runtime: decode_nexmon_pcap, summarize_nexmon_pcap (+ NexmonPcapSummary:
link type, CSI frame count, channels, bandwidths, subcarrier counts, chip
versions, RSSI range, time span), CaptureRuntime::open_nexmon_pcap[_bytes].

rvcsi-node (napi-rs): nexmonDecodePcap, inspectNexmonPcap, decodeChanspec,
RvcsiRuntime.openNexmonPcap. @ruv/rvcsi SDK + .d.ts updated (NexmonPcapSummary,
DecodedChanspec). rvcsi-cli: `record --source nexmon-pcap`, `inspect-nexmon`,
`decode-chanspec`.

161 rvcsi tests pass (adapter-nexmon 9->22), 0 failures, clippy-clean.
ADR-096 §2.2/§2.3/§5, CHANGELOG, CLAUDE.md updated.

https://claude.ai/code/session_01CdYAPvRTjcch6YrYf42n1z

v2/crates/rvcsi-node/src/lib.rs

@@ -93,6 +93,43 @@ pub fn export_capture_to_rf_memory(capture_path: String, out_jsonl_path: String)
     Ok(n as u32)
 }
 
+/// Decode the *real* nexmon_csi UDP payloads inside a libpcap `.pcap` `Buffer`
+/// into a JSON array of validated `CsiFrame`s. `port` is the CSI UDP port
+/// (omit / `null` ⇒ 5500). Throws if the buffer isn't a parseable classic pcap.
+#[napi]
+pub fn nexmon_decode_pcap(
+    pcap: Buffer,
+    source_id: String,
+    session_id: u32,
+    port: Option<u16>,
+) -> napi::Result<String> {
+    let frames = runtime::decode_nexmon_pcap(pcap.as_ref(), &source_id, session_id as u64, port)
+        .map_err(napi_err)?;
+    to_json(&frames)
+}
+
+/// Summarize a nexmon_csi `.pcap` file (link type, frame counts, channels,
+/// bandwidths, chip versions, RSSI range, time span); returns JSON for a
+/// `NexmonPcapSummary`. `port` defaults to 5500.
+#[napi]
+pub fn inspect_nexmon_pcap(path: String, port: Option<u16>) -> napi::Result<String> {
+    let summary = runtime::summarize_nexmon_pcap(&path, port).map_err(napi_err)?;
+    to_json(&summary)
+}
+
+/// Decode a Broadcom d11ac chanspec word; returns JSON
+/// `{ chanspec, channel, bandwidth_mhz, is_5ghz }`.
+#[napi]
+pub fn decode_chanspec(chanspec: u32) -> napi::Result<String> {
+    let d = rvcsi_adapter_nexmon::decode_chanspec((chanspec & 0xFFFF) as u16);
+    to_json(&serde_json::json!({
+        "chanspec": d.chanspec,
+        "channel": d.channel,
+        "bandwidth_mhz": d.bandwidth_mhz,
+        "is_5ghz": d.is_5ghz,
+    }))
+}
+
 // ---------------------------------------------------------------------------
 // Streaming runtime class
 // ---------------------------------------------------------------------------
@@ -121,6 +158,21 @@ impl RvcsiRuntime {
         })
     }
 
+    /// Open a real nexmon_csi `.pcap` capture as the source. `port` is the CSI
+    /// UDP port (omit / `null` ⇒ 5500).
+    #[napi(factory)]
+    pub fn open_nexmon_pcap(
+        path: String,
+        source_id: String,
+        session_id: u32,
+        port: Option<u16>,
+    ) -> napi::Result<RvcsiRuntime> {
+        Ok(RvcsiRuntime {
+            inner: CaptureRuntime::open_nexmon_pcap(&path, &source_id, session_id as u64, port)
+                .map_err(napi_err)?,
+        })
+    }
+
     /// Next exposable, validated frame as JSON, or `null` at end-of-stream.
     #[napi]
     pub fn next_frame_json(&mut self) -> napi::Result<Option<String>> {