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/tests/e2e.rs

@@ -16,8 +16,6 @@
 //! No external crates are used — the library forbids dependencies, so the
 //! harness sticks to `std` and the library's own public API.
 
-#![allow(clippy::doc_markdown)]
-
 use std::io::{Read, Write};
 use std::net::{TcpStream, ToSocketAddrs};
 use std::path::PathBuf;
@@ -64,10 +62,11 @@ impl TestServer {
             .unwrap_or_else(std::sync::PoisonError::into_inner);
 
         if let Ok(addr) = std::env::var("SOULSEEK_TEST_SERVER") {
-            let (host, port) = split_host_port(&addr)?;
-            wait_until_listening(&host, port, Duration::from_secs(2))?;
+            let (host, port) = addr.rsplit_once(':')?;
+            let port = port.parse().ok()?;
+            wait_until_listening(host, port, Duration::from_secs(2))?;
             return Some(Self {
-                host,
+                host: host.to_string(),
                 port,
                 child: None,
                 db: None,
@@ -152,11 +151,6 @@ impl Drop for TestServer {
     }
 }
 
-fn split_host_port(addr: &str) -> Option<(String, u16)> {
-    let (host, port) = addr.rsplit_once(':')?;
-    Some((host.to_string(), port.parse().ok()?))
-}
-
 fn soulfind_binary() -> Option<PathBuf> {
     if let Ok(p) = std::env::var("SOULFIND_BIN") {
         let p = PathBuf::from(p);
@@ -465,22 +459,6 @@ fn registered_username_can_relogin_with_same_password() {
     );
 }
 
-#[test]
-fn two_clients_can_be_logged_in_together() {
-    let server = server_or_skip!();
-
-    // The server must handle several independent sessions at once — this is
-    // the precondition for any peer-to-peer feature routed through it.
-    let mut alice = Client::with_settings(server.settings("e2e_alice", "pw_a"));
-    let mut bob = Client::with_settings(server.settings("e2e_bob", "pw_b"));
-
-    alice.connect().expect("alice connect");
-    bob.connect().expect("bob connect");
-
-    assert!(alice.login().expect("alice login"));
-    assert!(bob.login().expect("bob login"));
-}
-
 // ---------------------------------------------------------------------------
 // Peer-to-peer download coverage.
 //
@@ -2149,7 +2127,6 @@ fn a_peer_asking_where_it_sits_is_answered_with_its_place() {
     );
 
     // The asker keeps its own connection so it can read the answer back.
-    // The asker keeps its connection so it can read the answer back.
     let asker_file = format!("{folder}\\asker.mp3");
     let mut asker =
         queue_as(&server_addr, &listen_addr, "e2e_q_asker", &asker_file)