feat: Add wifi-Mat disaster detection enhancements

Implement 6 optional enhancements for the wifi-Mat module:

1. Hardware Integration (csi_receiver.rs + hardware_adapter.rs)
   - ESP32 CSI support via serial/UDP
   - Intel 5300 BFEE file parsing
   - Atheros CSI Tool integration
   - Live UDP packet streaming
   - PCAP replay capability

2. CLI Commands (wifi-densepose-cli/src/mat.rs)
   - `wifi-mat scan` - Run disaster detection scan
   - `wifi-mat status` - Check event status
   - `wifi-mat zones` - Manage scan zones
   - `wifi-mat survivors` - List detected survivors
   - `wifi-mat alerts` - View and acknowledge alerts
   - `wifi-mat export` - Export data in various formats

3. REST API (wifi-densepose-mat/src/api/)
   - Full CRUD for disaster events
   - Zone management endpoints
   - Survivor and alert queries
   - WebSocket streaming for real-time updates
   - Comprehensive DTOs and error handling

4. WASM Build (wifi-densepose-wasm/src/mat.rs)
   - Browser-based disaster dashboard
   - Real-time survivor tracking
   - Zone visualization
   - Alert management
   - JavaScript API bindings

5. Detection Benchmarks (benches/detection_bench.rs)
   - Single survivor detection
   - Multi-survivor detection
   - Full pipeline benchmarks
   - Signal processing benchmarks
   - Hardware adapter benchmarks

6. ML Models for Debris Penetration (ml/)
   - DebrisModel for material analysis
   - VitalSignsClassifier for triage
   - FFT-based feature extraction
   - Bandpass filtering
   - Monte Carlo dropout for uncertainty

All 134 unit tests pass. Compilation verified for:
- wifi-densepose-mat
- wifi-densepose-cli
- wifi-densepose-wasm (with mat feature)

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/integration/mod.rs

@@ -4,14 +4,102 @@
 //! - wifi-densepose-signal types and wifi-Mat domain types
 //! - wifi-densepose-nn inference results and detection results
 //! - wifi-densepose-hardware interfaces and sensor abstractions
+//!
+//! # Hardware Support
+//!
+//! The integration layer supports multiple WiFi CSI hardware platforms:
+//!
+//! - **ESP32**: Via serial communication using ESP-CSI firmware
+//! - **Intel 5300 NIC**: Using Linux CSI Tool (iwlwifi driver)
+//! - **Atheros NICs**: Using ath9k/ath10k/ath11k CSI patches
+//! - **Nexmon**: For Broadcom chips with CSI firmware
+//!
+//! # Example Usage
+//!
+//! ```ignore
+//! use wifi_densepose_mat::integration::{
+//!     HardwareAdapter, HardwareConfig, AtherosDriver,
+//!     csi_receiver::{UdpCsiReceiver, ReceiverConfig},
+//! };
+//!
+//! // Configure for ESP32
+//! let config = HardwareConfig::esp32("/dev/ttyUSB0", 921600);
+//! let mut adapter = HardwareAdapter::with_config(config);
+//! adapter.initialize().await?;
+//!
+//! // Or configure for Intel 5300
+//! let config = HardwareConfig::intel_5300("wlan0");
+//! let mut adapter = HardwareAdapter::with_config(config);
+//!
+//! // Or use UDP receiver for network streaming
+//! let config = ReceiverConfig::udp("0.0.0.0", 5500);
+//! let mut receiver = UdpCsiReceiver::new(config).await?;
+//! ```
 
 mod signal_adapter;
 mod neural_adapter;
 mod hardware_adapter;
+pub mod csi_receiver;
 
 pub use signal_adapter::SignalAdapter;
 pub use neural_adapter::NeuralAdapter;
-pub use hardware_adapter::HardwareAdapter;
+pub use hardware_adapter::{
+    // Main adapter
+    HardwareAdapter,
+    // Configuration types
+    HardwareConfig,
+    DeviceType,
+    DeviceSettings,
+    AtherosDriver,
+    ChannelConfig,
+    Bandwidth,
+    // Serial settings
+    SerialSettings,
+    Parity,
+    FlowControl,
+    // Network interface settings
+    NetworkInterfaceSettings,
+    AntennaConfig,
+    // UDP settings
+    UdpSettings,
+    // PCAP settings
+    PcapSettings,
+    // Sensor types
+    SensorInfo,
+    SensorStatus,
+    // CSI data types
+    CsiReadings,
+    CsiMetadata,
+    SensorCsiReading,
+    FrameControlType,
+    CsiStream,
+    // Health and stats
+    HardwareHealth,
+    HealthStatus,
+    StreamingStats,
+};
+
+pub use csi_receiver::{
+    // Receiver types
+    UdpCsiReceiver,
+    SerialCsiReceiver,
+    PcapCsiReader,
+    // Configuration
+    ReceiverConfig,
+    CsiSource,
+    UdpSourceConfig,
+    SerialSourceConfig,
+    PcapSourceConfig,
+    SerialParity,
+    // Packet types
+    CsiPacket,
+    CsiPacketMetadata,
+    CsiPacketFormat,
+    // Parser
+    CsiParser,
+    // Stats
+    ReceiverStats,
+};
 
 /// Configuration for integration layer
 #[derive(Debug, Clone, Default)]
@@ -22,6 +110,40 @@ pub struct IntegrationConfig {
     pub batch_size: usize,
     /// Enable signal preprocessing optimizations
     pub optimize_signal: bool,
+    /// Hardware configuration
+    pub hardware: Option<HardwareConfig>,
+}
+
+impl IntegrationConfig {
+    /// Create configuration for real-time processing
+    pub fn realtime() -> Self {
+        Self {
+            use_gpu: true,
+            batch_size: 1,
+            optimize_signal: true,
+            hardware: None,
+        }
+    }
+
+    /// Create configuration for batch processing
+    pub fn batch(batch_size: usize) -> Self {
+        Self {
+            use_gpu: true,
+            batch_size,
+            optimize_signal: true,
+            hardware: None,
+        }
+    }
+
+    /// Create configuration with specific hardware
+    pub fn with_hardware(hardware: HardwareConfig) -> Self {
+        Self {
+            use_gpu: true,
+            batch_size: 1,
+            optimize_signal: true,
+            hardware: Some(hardware),
+        }
+    }
 }
 
 /// Error type for integration layer
@@ -46,4 +168,68 @@ pub enum AdapterError {
     /// Data format error
     #[error("Data format error: {0}")]
     DataFormat(String),
+
+    /// I/O error
+    #[error("I/O error: {0}")]
+    Io(#[from] std::io::Error),
+
+    /// Timeout error
+    #[error("Timeout error: {0}")]
+    Timeout(String),
+}
+
+/// Prelude module for convenient imports
+pub mod prelude {
+    pub use super::{
+        AdapterError,
+        HardwareAdapter,
+        HardwareConfig,
+        DeviceType,
+        AtherosDriver,
+        Bandwidth,
+        CsiReadings,
+        CsiPacket,
+        CsiPacketFormat,
+        IntegrationConfig,
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_integration_config_defaults() {
+        let config = IntegrationConfig::default();
+        assert!(!config.use_gpu);
+        assert_eq!(config.batch_size, 0);
+        assert!(!config.optimize_signal);
+        assert!(config.hardware.is_none());
+    }
+
+    #[test]
+    fn test_integration_config_realtime() {
+        let config = IntegrationConfig::realtime();
+        assert!(config.use_gpu);
+        assert_eq!(config.batch_size, 1);
+        assert!(config.optimize_signal);
+    }
+
+    #[test]
+    fn test_integration_config_batch() {
+        let config = IntegrationConfig::batch(32);
+        assert!(config.use_gpu);
+        assert_eq!(config.batch_size, 32);
+    }
+
+    #[test]
+    fn test_integration_config_with_hardware() {
+        let hw_config = HardwareConfig::esp32("/dev/ttyUSB0", 921600);
+        let config = IntegrationConfig::with_hardware(hw_config);
+        assert!(config.hardware.is_some());
+        assert!(matches!(
+            config.hardware.as_ref().unwrap().device_type,
+            DeviceType::Esp32
+        ));
+    }
 }