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/index.js

@@ -91,6 +91,41 @@ function exportCaptureToRfMemory(capturePath, outJsonlPath) {
   return binding().exportCaptureToRfMemory(String(capturePath), String(outJsonlPath));
 }
 
+/**
+ * Decode the *real* nexmon_csi UDP payloads inside a libpcap `.pcap` buffer
+ * (`tcpdump -i wlan0 dst port 5500 -w csi.pcap`) into validated CsiFrame objects.
+ * @param {Buffer|Uint8Array} pcap
+ * @param {string} sourceId
+ * @param {number} sessionId
+ * @param {number} [port] CSI UDP port (default 5500)
+ * @returns {import('./index').CsiFrame[]}
+ */
+function nexmonDecodePcap(pcap, sourceId, sessionId, port) {
+  return JSON.parse(
+    binding().nexmonDecodePcap(pcap, String(sourceId), u32(sessionId), port == null ? undefined : Number(port)),
+  );
+}
+
+/**
+ * Summarize a nexmon_csi `.pcap` file (link type, CSI frame count, channels,
+ * bandwidths, chip versions, RSSI range, time span).
+ * @param {string} path
+ * @param {number} [port] CSI UDP port (default 5500)
+ * @returns {import('./index').NexmonPcapSummary}
+ */
+function inspectNexmonPcap(path, port) {
+  return JSON.parse(binding().inspectNexmonPcap(String(path), port == null ? undefined : Number(port)));
+}
+
+/**
+ * Decode a Broadcom d11ac chanspec word.
+ * @param {number} chanspec
+ * @returns {import('./index').DecodedChanspec}
+ */
+function decodeChanspec(chanspec) {
+  return JSON.parse(binding().decodeChanspec(u32(chanspec)));
+}
+
 /** Streaming capture runtime: a source + the DSP stage + the event pipeline. */
 class RvCsi {
   /** @param {*} rt the underlying napi RvcsiRuntime handle */
@@ -112,6 +147,22 @@ class RvCsi {
     return new RvCsi(binding().RvcsiRuntime.openNexmonFile(String(path), String(sourceId), u32(sessionId)));
   }
 
+  /**
+   * Open a real nexmon_csi `.pcap` capture.
+   * @param {string} path @param {string} sourceId @param {number} sessionId
+   * @param {number} [port] CSI UDP port (default 5500) @returns {RvCsi}
+   */
+  static openNexmonPcap(path, sourceId, sessionId, port) {
+    return new RvCsi(
+      binding().RvcsiRuntime.openNexmonPcap(
+        String(path),
+        String(sourceId),
+        u32(sessionId),
+        port == null ? undefined : Number(port),
+      ),
+    );
+  }
+
   /** Next exposable, validated frame, or `null` at end-of-stream. @returns {import('./index').CsiFrame|null} */
   nextFrame() {
     const s = this._rt.nextFrameJson();
@@ -149,6 +200,9 @@ module.exports = {
   rvcsiVersion,
   nexmonShimAbiVersion,
   nexmonDecodeRecords,
+  nexmonDecodePcap,
+  inspectNexmonPcap,
+  decodeChanspec,
   inspectCaptureFile,
   eventsFromCaptureFile,
   exportCaptureToRfMemory,