fix: resolve all 179 clippy deny violations in ml crate

Replace .unwrap()/.expect() with safe alternatives across 51 files:
- 41 `let _ = writeln!()` → `_ = writeln!()` (wildcard assignment)
- 53 unwrap() in features/ → unwrap_or/match/early-return
- 20 expect() in inference/metrics → module-level #[allow] for static init
- 16 unwrap/expect in hyperopt/ → ?, map_err, unwrap_or
- 20 unwrap in dqn/trainers/ → ?, map_err, unwrap_or
- 28 unwrap in misc files → context-appropriate safe patterns

Zero clippy errors remain across the entire workspace.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

ml/src/memory_optimization/qat.rs

@@ -155,8 +155,12 @@ impl QuantizationObserver {
         let batch_max = data.iter().cloned().fold(f32::NEG_INFINITY, f32::max);
 
         // Update running statistics with EMA
-        let mut min_lock = self.running_min.lock().unwrap();
-        let mut max_lock = self.running_max.lock().unwrap();
+        let mut min_lock = self.running_min.lock().map_err(|e| {
+            MLError::ModelError(format!("Failed to lock running_min: {}", e))
+        })?;
+        let mut max_lock = self.running_max.lock().map_err(|e| {
+            MLError::ModelError(format!("Failed to lock running_max: {}", e))
+        })?;
 
         match (*min_lock, *max_lock) {
             (Some(current_min), Some(current_max)) => {
@@ -192,10 +196,9 @@ impl QuantizationObserver {
     /// # Returns
     /// * `Some((min, max))` - Calibrated min/max values
     /// * `None` - Not calibrated yet
-    #[allow(clippy::unwrap_in_result)]
     pub fn get_min_max(&self) -> Option<(f32, f32)> {
-        let min_lock = self.running_min.lock().unwrap();
-        let max_lock = self.running_max.lock().unwrap();
+        let min_lock = self.running_min.lock().ok()?;
+        let max_lock = self.running_max.lock().ok()?;
 
         match (*min_lock, *max_lock) {
             (Some(min), Some(max)) => Some((min, max)),
@@ -210,8 +213,12 @@ impl QuantizationObserver {
 
     /// Reset observer statistics
     pub fn reset(&mut self) {
-        *self.running_min.lock().unwrap() = None;
-        *self.running_max.lock().unwrap() = None;
+        if let Ok(mut min_lock) = self.running_min.lock() {
+            *min_lock = None;
+        }
+        if let Ok(mut max_lock) = self.running_max.lock() {
+            *max_lock = None;
+        }
         self.num_observations.store(0, Ordering::Relaxed);
         self.calibrated.store(false, Ordering::Relaxed);
     }