feat: TCP-only builds; TCP options and timeouts; receives that report and keep what arrived

- --no-quic leaves QUIC, HTTP/3 and WebTransport out of the build, and with
  them msquic: a consumer that only needs TCP builds no msquic. The flag
  isn't passed on to dependencies.
- --local takes Crafter.Thread from the sibling checkout, as the other
  Crafter projects do.
- ClientTCP gains SetNoDelay, SetReceiveTimeout, a connect timeout and
  SocketTimeoutException.
- TCP receives return the bytes that arrived:
  - RecieveSync(n) returned the whole buffer when fewer had come;
  - RecieveUntilCloseSync truncated what it had read;
  - a signal (EINTR) during a receive threw where it should wait on;
  - RecieveSync(size, buffer) returns the count and throws like the others;
  - a receive of no bytes returns at once: recv's 0 for it isn't a close.
- Every TCP *Async receive takes an onError(std::exception_ptr): an
  exception escaping a ThreadPool task ended the program. An empty onError
  drops the error.
- QUIC streams:
  - async receives deliver an empty chunk on close, as the browser build does;
  - RecieveUntilFullAsync gives what arrived on a stream that closes early;
  - RecieveUntilFullSync takes all it asked for or nothing, under one hold
    of the lock, so what did arrive stays for the next receive and no
    other receive can take bytes from among it;
  - SendAsync's callback hears whether the send went out (bool sent): native,
    browser, the JS bridge and the example.
- msquic is pinned to v2.6.3 and built against the system OpenSSL
  (QUIC_TLS_LIB=openssl, 3.5 or newer). Its bundled quictls read the system's
  openssl.cnf, and the Flatpak runtime's (a PKCS#11 engine, with
  config_diagnostics on) made it fail to initialise. The README says to use
  --no-quic where the distro's OpenSSL is older.
- Tests now register on any Linux triple: they never ran under the Flatpak's
  x86_64-unknown-linux-gnu. New: ShouldBuildWithoutQUIC, ShouldConfigureTCP,
  ShouldRecieveTCP, ShouldReportClosedQUICStream.

Breaking: SendAsync's callback takes a bool, the TCP *Async receives take
an onError, and RecieveSync(size, buffer) returns the count.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

interfaces/Crafter.Network-ClientQUIC.cppm

@@ -126,19 +126,25 @@ namespace Crafter {
         // Read until the peer closes the send-side, accumulating all chunks.
         std::vector<char> RecieveUntilCloseSync();
 
-        // Read exactly bufferSize bytes; throws if the peer closes early.
+        // Read exactly bufferSize bytes. Throws if the peer closes early,
+        // leaving what did arrive for the next receive.
         std::vector<char> RecieveUntilFullSync(std::uint32_t bufferSize);
 #endif
 
         // Send a buffer. If finish=true, the send-side is closed after the
-        // buffer is delivered. onSent fires once the transport has accepted
-        // the buffer (native) or the WritableStream writer has resolved
-        // (browser). Available on both native and browser builds.
+        // buffer is delivered. onSent fires with true once the transport has
+        // accepted the buffer (native) or the WritableStream writer has
+        // resolved (browser), and with false when the stream was closed or
+        // the send failed. Available on both native and browser builds.
         void SendAsync(const void* buffer, std::uint32_t size, bool finish,
-                       std::function<void()> onSent);
+                       std::function<void(bool sent)> onSent);
 
         // Async receive variants. Dispatched on Crafter.Thread's ThreadPool
-        // (native) or driven by a per-stream JS reader loop (browser).
+        // (native) or driven by a per-stream JS reader loop (browser). A
+        // stream that has closed gives the callback an empty chunk, and
+        // RecieveUntilFullAsync on one that closes early gives what arrived:
+        // the browser build has no exceptions to report it with, and on the
+        // ThreadPool an exception would end the program.
         void RecieveAsync(std::function<void(std::vector<char>)> recieveCallback);
         void RecieveUntilCloseAsync(std::function<void(std::vector<char>)> recieveCallback);
         void RecieveUntilFullAsync(std::uint32_t bufferSize, std::function<void(std::vector<char>)> recieveCallback);