refactor: cut what a whole-repo audit proved dead, padded, or hand-rolled

Seven region audits, every finding adversarially verified against the
whole workspace before being applied; 80 landed and the two that failed
in application were refuted honestly (ParseError has a from_str_radix
producer the audit missed; NatPmpError's Display is the only reader of
its diagnostic payloads).

The bigger cuts:

- The NewPeer/PierceFireWall cluster: an operation variant nothing ever
  sent, its 77-line arm, a protocol-wrong Client::pierce_firewall that
  wrote a peer-init frame down the server socket, and the struct only
  they used. The live paths in peer/listen.rs are untouched.
- The ops loop reads `for operation in reader` instead of hand-rolling
  recv/break, de-indenting the whole dispatch body.
- Dead lib surface: Message::print_hex and four unused accessors,
  UploadFailed, registry and actor getters, build_watch_user,
  strip_ansi_codes, delegating shims on ClientContext. Removing public
  items makes this a semver major, which the release pipeline enforces.
- Never-used flexibility: the state-migration framework that never held
  a migration, border-type helpers that all answered Rounded, the TUI's
  max_concurrent_downloads field nothing read.
- Convergence: six poll loops into poll_until, three wrap-around
  navigation blocks into cycle, hit tests into Rect::contains, char
  walkers into floor/ceil_char_boundary, five Download literals into
  one helper, the suites' shared scaffolding into tests/common.

Deliberately not taken: swapping the hand-rolled zlib inflate and MD5
for crates (they replace wire-facing machinery whose tolerance of
real-world peer quirks no local test exercises) and pulling chrono into
the lib for a log timestamp. Recorded for their own decision.

Net -1002 lines. Both e2e modes stay green: 94 CLI tests each way, 16
protocol, 33 lib, unit suites, clippy pedantic clean, aislop 100/100
with the four scanner false positives suppressed inline where they
fire.

soulseek-rs-lib/src/actor/peer_actor.rs

@@ -184,13 +184,7 @@ impl PeerActor {
         let messages: Vec<PeerMessage> = self
             .dispatcher_receiver
             .as_ref()
-            .map_or_else(Vec::new, |receiver| {
-                let mut msgs = Vec::new();
-                while let Ok(msg) = receiver.try_recv() {
-                    msgs.push(msg);
-                }
-                msgs
-            });
+            .map_or_else(Vec::new, |receiver| receiver.try_iter().collect());
 
         for msg in &messages {
             self.handle_message(msg.clone());
@@ -690,45 +684,20 @@ impl PeerActor {
         }
     }
 
-    fn initiate_connection(&mut self) -> bool {
+    fn initiate_connection(&mut self) {
         let (username, host, port) = match self.peer.read_safe() {
             Ok(peer) => (peer.username.clone(), peer.host.clone(), peer.port),
             Err(e) => {
                 error!("[peer_actor] initiate_connection peer lock: {}", e);
-                return false;
+                return;
             }
         };
 
         let socket_addr =
             format!("{host}:{port}").parse::<std::net::SocketAddr>();
 
-        match socket_addr {
-            Ok(addr) => {
-                // Use connect_timeout to prevent blocking the thread for too long
-                let timeout = Duration::from_secs(5);
-                match TcpStream::connect_timeout(&addr, timeout) {
-                    Ok(stream) => {
-                        if let Err(e) = stream.set_nonblocking(true) {
-                            error!(
-                                "[peer:{}] Failed to set non-blocking: {}",
-                                username, e
-                            );
-                            self.disconnect_with_error(e);
-                            return false;
-                        }
-                        stream.set_nodelay(true).ok();
-                        self.stream = Some(stream);
-                        self.connection_state = ConnectionState::Connecting {
-                            since: Instant::now(),
-                        };
-                        true
-                    }
-                    Err(e) => {
-                        self.disconnect_with_error(e);
-                        false
-                    }
-                }
-            }
+        let addr = match socket_addr {
+            Ok(addr) => addr,
             Err(e) => {
                 error!(
                     "[peer:{}] Invalid socket address {}:{} - {}",
@@ -738,9 +707,30 @@ impl PeerActor {
                     io::ErrorKind::InvalidInput,
                     e,
                 ));
-                false
+                return;
             }
+        };
+
+        // Use connect_timeout to prevent blocking the thread for too long
+        let timeout = Duration::from_secs(5);
+        let stream = match TcpStream::connect_timeout(&addr, timeout) {
+            Ok(stream) => stream,
+            Err(e) => {
+                self.disconnect_with_error(e);
+                return;
+            }
+        };
+
+        if let Err(e) = stream.set_nonblocking(true) {
+            error!("[peer:{}] Failed to set non-blocking: {}", username, e);
+            self.disconnect_with_error(e);
+            return;
         }
+        stream.set_nodelay(true).ok();
+        self.stream = Some(stream);
+        self.connection_state = ConnectionState::Connecting {
+            since: Instant::now(),
+        };
     }
 
     fn check_connection_status(&mut self) {