fix(rust): revert anti-pattern .expect("TODO") to .unwrap() in tests (12 sites)

12 test-only sites in src/rust/src/{crypto,ecm}/ were using
.expect("TODO: handle error") — identical panic to .unwrap() but with
a fake debt marker that makes future review noisier. Standing rule
treats this as an anti-pattern: revert on sight.

All sites are inside #[cfg(test)] / #[test] functions where panicking
on Err/None is the correct test verdict, so .unwrap() is the right
form. cargo test --lib: 20/20 green.

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

Author: hyperpolymath

src/rust/src/crypto/mod.rs

@@ -233,27 +233,27 @@ mod tests {
 
     #[test]
     fn kyber1024_round_trip() {
-        let keypair = kem_keygen(KemAlgorithm::Kyber1024).expect("TODO: handle error");
-        let encap = kem_encapsulate(&keypair.public_key, KemAlgorithm::Kyber1024).expect("TODO: handle error");
-        let decap = kem_decapsulate(&encap.ciphertext, &keypair.secret_key, KemAlgorithm::Kyber1024).expect("TODO: handle error");
+        let keypair = kem_keygen(KemAlgorithm::Kyber1024).unwrap();
+        let encap = kem_encapsulate(&keypair.public_key, KemAlgorithm::Kyber1024).unwrap();
+        let decap = kem_decapsulate(&encap.ciphertext, &keypair.secret_key, KemAlgorithm::Kyber1024).unwrap();
         assert_eq!(encap.shared_secret, decap);
     }
 
     #[test]
     fn dilithium5_sign_verify() {
-        let keypair = sig_keygen(SignatureAlgorithm::Dilithium5).expect("TODO: handle error");
+        let keypair = sig_keygen(SignatureAlgorithm::Dilithium5).unwrap();
         let message = b"DEFENSIVE USE ONLY";
-        let signed = sign(message, &keypair.secret_key, SignatureAlgorithm::Dilithium5).expect("TODO: handle error");
-        let opened = verify(&signed, &keypair.public_key, SignatureAlgorithm::Dilithium5).expect("TODO: handle error");
+        let signed = sign(message, &keypair.secret_key, SignatureAlgorithm::Dilithium5).unwrap();
+        let opened = verify(&signed, &keypair.public_key, SignatureAlgorithm::Dilithium5).unwrap();
         assert_eq!(opened, message);
     }
 
     #[test]
     fn sphincs_sign_verify() {
-        let keypair = sig_keygen(SignatureAlgorithm::SphincsPlusSha2256f).expect("TODO: handle error");
+        let keypair = sig_keygen(SignatureAlgorithm::SphincsPlusSha2256f).unwrap();
         let message = b"post-quantum fallback";
-        let signed = sign(message, &keypair.secret_key, SignatureAlgorithm::SphincsPlusSha2256f).expect("TODO: handle error");
-        let opened = verify(&signed, &keypair.public_key, SignatureAlgorithm::SphincsPlusSha2256f).expect("TODO: handle error");
+        let signed = sign(message, &keypair.secret_key, SignatureAlgorithm::SphincsPlusSha2256f).unwrap();
+        let opened = verify(&signed, &keypair.public_key, SignatureAlgorithm::SphincsPlusSha2256f).unwrap();
         assert_eq!(opened, message);
     }
 }

src/rust/src/ecm/mod.rs

@@ -173,8 +173,8 @@ mod tests {
         let (peak_freq, _peak_power) = spectrum
             .iter()
             .copied()
-            .max_by(|a, b| a.1.partial_cmp(&b.1).expect("TODO: handle error"))
-            .expect("TODO: handle error");
+            .max_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
+            .unwrap();
 
         // Peak should be within one frequency bin of 1000 Hz.
         let bin_width = sig.sample_rate_hz / sig.num_samples as f64;

src/rust/src/ecm/signals.rs

@@ -147,6 +147,6 @@ mod tests {
 
         assert!(snapshot.has_jamming());
         assert_eq!(snapshot.count_by_class(SignalClassification::SuspectedJamming), 1);
-        assert_eq!(snapshot.strongest_signal().expect("TODO: handle error").snr_db, 60.0);
+        assert_eq!(snapshot.strongest_signal().unwrap().snr_db, 60.0);
     }
 }