perf(peer): widen LAN bulk-transfer windows and buffers

Centralize the bulk-transfer sizing in config.rs and bump the values used
on both ends of a QUIC connection:

- CHUNK_SIZE: 32 MiB -> 128 MiB
- QUIC_CONNECTION_DATA_WINDOW: 64 MiB -> 256 MiB
- QUIC_STREAM_DATA_WINDOW: 32 MiB -> 128 MiB
- QUIC_MAX_SEND_BUFFER_SIZE: 32 MiB -> 128 MiB
- QUIC_INITIAL_CONGESTION_WINDOW: 1 MiB -> 4 MiB
- FILE_TRANSFER_BUFFER_SIZE: 64 KiB -> 1 MiB (new constant)

The previous 32 MiB stream window was already comfortably above the
bandwidth-delay product of a sub-millisecond LAN at 2.5 GbE. The further
bump is deliberately generous: the goal is to push flow control and
per-syscall overhead far enough out of the way that they cannot be the
suspect when isolating the remaining LAN download bottleneck (disk, NIC,
or s2n-quic platform offload on the sending host). Memory pressure from
the larger windows is not observable on a desktop client moving GB-sized
games.

stream_file_bytes previously read the local file in 64 KiB chunks. At
multi-Gbit/s send rates that produced many thousands of disk reads per
second; bumping to 1 MiB keeps the per-file syscall load modest with no
measurable latency cost on streamed bulk transfers. The buffer size lives
in config.rs as FILE_TRANSFER_BUFFER_SIZE so it stays adjustable from one
place.

Also add a started/MiB-per-second log line at info level when a file
finishes streaming. This matches the S37 measurement methodology already
used in the peer-cli harness and makes per-file send throughput visible in
normal operation.

The peer-cli extended-scenarios harness uses CHUNK_SIZE as the tolerance
bound for chunk-boundary variance in its assertions, so its constant is
bumped to match. The multi-chunk planning unit test is rewritten to
reference CHUNK_SIZE symbolically (CHUNK_SIZE * 3 + CHUNK_SIZE / 2)
instead of a hardcoded 120 MiB; the previous literal would silently
degrade into a single-chunk test at the new chunk size and stop
exercising the spread-across-peers code path.

Test Plan:
- just fmt
- just clippy
- just test
- python3 crates/lanspread-peer-cli/scripts/run_extended_scenarios.py S37 \
  --build-image
- python3 crates/lanspread-peer-cli/scripts/run_extended_scenarios.py S37

Refs: local LAN download performance investigation on 2026-05-20.
Depends-on: d7f7dc737e (QUIC UDP socket buffer sizing).

crates/lanspread-peer/src/peer.rs

@@ -12,7 +12,7 @@ use tokio::{
     time::Instant,
 };
 
-use crate::path_validation::validate_game_file_path;
+use crate::{config::FILE_TRANSFER_BUFFER_SIZE, path_validation::validate_game_file_path};
 
 async fn stream_file_bytes(
     tx: &mut SendStream,
@@ -40,8 +40,9 @@ async fn stream_file_bytes(
     let mut transfer_complete = matches!(length, Some(0));
     let mut total_bytes = 0u64;
     let mut last_total_bytes = 0u64;
+    let started = Instant::now();
     let mut timestamp = Instant::now();
-    let mut buf = vec![0u8; 64 * 1024];
+    let mut buf = vec![0u8; FILE_TRANSFER_BUFFER_SIZE];
 
     while remaining > 0 {
         let read_len = std::cmp::min(remaining, buf.len() as u64);
@@ -84,8 +85,15 @@ async fn stream_file_bytes(
         }
     }
 
-    log::debug!(
-        "{remote_addr} finished streaming file bytes: {}, total_bytes: {total_bytes}",
+    let elapsed = started.elapsed();
+    #[allow(clippy::cast_precision_loss)]
+    let mib_per_s = if elapsed.as_secs_f64() > 0.0 {
+        total_bytes as f64 / elapsed.as_secs_f64() / (1024.0 * 1024.0)
+    } else {
+        0.0
+    };
+    log::info!(
+        "{remote_addr} finished streaming file bytes: {}, total_bytes: {total_bytes}, MiB/s: {mib_per_s:.2}",
         validated_path.display()
     );