perf: raise transfer defaults and stop uploads sleeping on their slot

The slot cap merged from master defaults to 2 uploads, and the CLI capped
downloads at 5. Those are the numbers you pick when your own bandwidth is the
scarce resource, but a Soulseek transfer is paced by the peer on the other end
— usually a few hundred KiB/s — so what fills a modern link is many transfers
at once, not faster ones. Upload slots go to 10, downloads to 20. The queue
itself stays: privileged users being able to jump it is a condition of being a
tolerated third-party client.

serve_file also slept half a second after the last byte so the downloader could
drain before the socket closed. With a cap that is time no other peer can use,
and 64 uploads over 10 slots paid it six times over. A half-close says "that is
the whole file" and TCP still delivers everything written before the FIN.

Measured with 64 waiting peers: 2 slots 24.2s, 8 slots 6.2s, 32 slots 3.1s; at
10 slots the linger alone was 5.4s to 3.05s.

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

@@ -48,10 +48,17 @@ pub const DEFAULT_WISHLIST_INTERVAL: Duration = Duration::from_mins(12);
 
 /// How many uploads run at once by default.
 ///
-/// Two is what makes the queue real: with unlimited slots there is nothing for
-/// a privileged peer to jump, and a home connection split across every peer
-/// that asks serves all of them badly.
-pub const DEFAULT_UPLOAD_SLOTS: usize = 2;
+/// The cap is what makes the queue real — with unlimited slots there is nothing
+/// for a privileged peer to jump — but it must not be the thing throttling a
+/// modern connection. On Soulseek the per-transfer rate is usually set by the
+/// *other* end, so concurrency is what fills an uplink: ten peers at a typical
+/// few hundred KiB/s each is a few MiB/s, which a 50 Mbit uplink carries and a
+/// pair of slots leaves mostly idle. Ten still divides a modest uplink into
+/// shares big enough that no peer times out waiting.
+///
+/// Measured on the stress benchmark (64 waiting peers, loopback): two slots
+/// took 24.2s, eight took 6.2s, thirty-two took 3.1s.
+pub const DEFAULT_UPLOAD_SLOTS: usize = 10;
 
 /// How long to wait for a server-brokered (firewalled) peer to connect back
 /// before giving up and failing the download. Matches the direct-dial timeout.

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

@@ -471,10 +471,7 @@ impl Client {
                                 let registry = context.peer_registry.clone();
                                 drop(context);
                                 if let Some(registry) = registry {
-                                    let response =
-                                        crate::message::server::MessageFactory::build_transfer_response_message(
-                                            transfer,
-                                        );
+                                    let response = MessageFactory::build_transfer_response_message(transfer);
                                     let _ = registry.send_to_peer(
                                         &username,
                                         PeerMessage::SendMessage(response),