feat!: wishlist, upload-queue privilege recognition, and search filters (#20)

Closes the last two gaps in Soulseek's list of features an alternative client
must implement to be tolerated, and adds the result filters Nicotine+ has had
all along.

Wishlist: server code 103 is sent and code 104's announced interval is kept
rather than logged and discarded, so the re-search timer runs off the schedule
the server set. `wish add|remove|list|run` plus `serve --wishlist`; wishes
persist in config.toml as a TOML array so a comma inside a query survives.
`wish run` prints search-shaped records, so it pipes into `download --stdin`.

Privilege recognition: the code-69 user list is parsed instead of counted and
dropped, and code 92 answers `whoami` as `privilege_seconds`. Uploads now go
through a queue with a slot cap (`--upload-slots`, default 2) that serves
privileged users first — the cap is what makes the ordering mean anything, so
they are one change. `PlaceInQueueRequest` (peer code 51) is answered, where it
previously had no handler at all, and a departed peer's slot is released so a
stalled peer cannot wedge uploads shut.

Search filters: `--exclude`, `--extension`, `--min-size`, `--max-size` beside
the existing `--min-bitrate` and `--free-slots`, in one flattened arg group
shared by `search`, `get` and `wish run`.

Also serialises the library e2e suite behind the same gate `cli_e2e` already
uses: the new queue tests hold peer sockets open on purpose, which starved
concurrently-spawned soulfinds and failed unrelated download tests with
`login: Timeout`.

BREAKING CHANGE: `UploadStatus` gains a `Queued(u32)` variant, so an exhaustive
match on it no longer compiles, and `cli::Commands` gains `Wish`.

soulseek-rs-lib/src/client/search.rs

@@ -1,7 +1,7 @@
 use super::{
-    Arc, AtomicBool, Client, Duration, HashMap, Instant, Ordering, Result,
-    RwLockExt, Search, SearchResult, ServerMessage, SoulseekRs, info, md5,
-    sleep,
+    Arc, AtomicBool, Client, DEFAULT_WISHLIST_INTERVAL, Duration, HashMap,
+    Instant, Ordering, Result, RwLockExt, Search, SearchResult, ServerMessage,
+    SoulseekRs, info, md5, sleep,
 };
 
 impl Client {
@@ -13,53 +13,95 @@ impl Client {
         self.search_with_cancel(query, timeout, None)
     }
 
+    /// Send `query` as a wishlist search (server code 103) and return at once.
+    ///
+    /// Results accumulate under `query`, so the caller reads them back with
+    /// [`Client::get_search_results`] after waiting however long it wants to.
+    /// Starting several wishes and then waiting once is the whole point: waiting
+    /// per wish would cost one full search window each.
+    ///
+    /// The server rate-limits these to the interval it announced — see
+    /// [`Client::wishlist_interval`] — so a wish re-sent sooner than that comes
+    /// back empty.
+    ///
+    /// # Errors
+    /// [`SoulseekRs::NotConnected`] when there is no server connection.
+    pub fn start_wishlist_search(&self, query: &str) -> Result<()> {
+        self.send_search(query, true)
+    }
+
+    /// How long to wait between wishlist searches: what the server announced in
+    /// code 104, or [`DEFAULT_WISHLIST_INTERVAL`] until it has.
+    #[must_use]
+    pub fn wishlist_interval(&self) -> Duration {
+        self.context
+            .read_safe()
+            .ok()
+            .and_then(|ctx| ctx.wishlist_interval)
+            .map_or(DEFAULT_WISHLIST_INTERVAL, |seconds| {
+                Duration::from_secs(u64::from(seconds))
+            })
+    }
+
     pub fn search_with_cancel(
         &self,
         query: &str,
         timeout: Duration,
         cancel_flag: Option<Arc<AtomicBool>>,
     ) -> Result<Vec<SearchResult>> {
+        self.send_search(query, false)?;
+        Self::collect_for(timeout, cancel_flag);
+        Ok(self.get_search_results(query))
+    }
+
+    /// Register `query` and put its search on the wire. Returns as soon as the
+    /// message is queued; nothing has answered yet.
+    fn send_search(&self, query: &str, wishlist: bool) -> Result<()> {
         info!("Searching for {}", query);
 
-        if let Some(handle) = &self.server_handle {
-            let hash = md5::md5(query);
-            let token = u32::from_str_radix(&hash[0..5], 16)?;
-
-            self.context.write_safe()?.searches.insert(
-                query.to_string(),
-                Search {
-                    token,
-                    results: Vec::new(),
-                },
-            );
-
-            let _ = handle.send(ServerMessage::FileSearch {
-                token,
-                query: query.to_string(),
-            });
-        } else {
+        let Some(handle) = &self.server_handle else {
             return Err(SoulseekRs::NotConnected);
-        }
+        };
+        let hash = md5::md5(query);
+        let token = u32::from_str_radix(&hash[0..5], 16)?;
 
+        self.context.write_safe()?.searches.insert(
+            query.to_string(),
+            Search {
+                token,
+                results: Vec::new(),
+            },
+        );
+
+        let query = query.to_string();
+        let _ = handle.send(if wishlist {
+            ServerMessage::WishlistSearch { token, query }
+        } else {
+            ServerMessage::FileSearch { token, query }
+        });
+        Ok(())
+    }
+
+    /// Let responses accumulate for `timeout`, or until cancelled.
+    ///
+    /// Peers answer a search over their own connections whenever they get round
+    /// to it, so there is nothing to await — the window is the whole protocol.
+    /// Late responders are often the better sources, which is why this runs the
+    /// window out rather than returning on the first hit.
+    pub fn collect_for(
+        timeout: Duration,
+        cancel_flag: Option<Arc<AtomicBool>>,
+    ) {
         let start = Instant::now();
-        loop {
+        while start.elapsed() < timeout {
             sleep(Duration::from_millis(100));
-
-            // Check if cancelled
-            if let Some(ref flag) = cancel_flag
+            if let Some(flag) = &cancel_flag
                 && flag.load(Ordering::Relaxed)
             {
                 info!("Search cancelled by user");
-                break;
-            }
-
-            // Check if timeout reached
-            if start.elapsed() >= timeout {
-                break;
+                return;
             }
         }
-
-        Ok(self.get_search_results(query))
     }
 
     #[must_use]