docs: state honestly that the L4 pool cannot register a hit

README advertised sluice_pool_hits_total 4821 for a pool that is structurally
incapable of a hit on the L4 path: each copy direction half-closes its
destination, and TestPooledConnHalfClosedIsNotPooled asserts a half-closed
connection is never pooled, so every L4 request dials a fresh socket.

Making the counter move requires not forwarding the client FIN. That was
implemented and reverted (kept on attempted/tcp-pool-reuse) because it broke
two things that matter more than reuse: a client that half-closes and waits
received an empty response, and the abandoned socket went back into the pool
still owing a reply, so the next client could be served the previous client's
response body. Both reproduced.

config.example.yaml shipped enabled: true while the README called pooling
opt-in. It now ships disabled, with the reason inline.

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

Author: abd-ulbasit

README.md

@@ -296,10 +296,28 @@ misspelled optional key disables a feature with no error and no log line.
 sluice_backend_health{backend="10.0.0.5:8080"} 1
 sluice_circuit_breaker_state{backend="10.0.0.5:8080"} 0   # 0=closed 1=open 2=half-open
 sluice_rate_limiter_requests_total{result="rejected"} 0
-sluice_pool_hits_total{backend="10.0.0.5:8080"} 4821
+sluice_pool_hits_total{backend="10.0.0.5:8080"} 0
+sluice_pool_misses_total{backend="10.0.0.5:8080"} 0
 sluice_request_duration_seconds_bucket{le="0.05"} 19204
 ```
 
+### The L4 pool hit counter stays at zero, by construction
+
+Not a misconfiguration. Each copy direction ends by half-closing its
+destination (`internal/proxy/tcp.go`, the `CloseWrite` after the copy loop),
+and a half-closed connection is never returned to the pool. That second half is
+asserted by `TestPooledConnHalfClosedIsNotPooled` in
+`internal/backend/backend_test.go`. Put together, every L4 request dials a
+fresh backend socket, so the hit counter cannot move on that path.
+
+Making it move means not forwarding the client's FIN to the backend. That was
+tried and it is worse than an idle counter: a client that half-closes and then
+waits receives an empty response, and because the abandoned socket is returned
+to the pool with a reply still owed on it, the next client can be served the
+previous client's response body. Both were reproduced before the change was
+reverted. Connection reuse is not worth a protocol-visible correctness bug, so
+the pool remains useful on the L7 path and the L4 counter stays honest.
+
 Admin API: `GET /health`, `GET /stats`, `GET /backends`.
 
 ## Architecture

config.example.yaml

@@ -79,8 +79,12 @@ server:
   # Reuse of idle TCP connections to backends, for the L4 path. Connections are
   # liveness-checked before reuse (zero read deadline + 1-byte read), so a
   # backend that closed an idle connection does not surface as a failed request.
+  # Off by default. On the L4 path this can never register a hit: each copy
+  # direction half-closes its destination and a half-closed connection is not
+  # poolable, so enabling it only adds bookkeeping. See the observability
+  # section of the README for why making it work is the wrong trade.
   tcp_pool:
-    enabled: true
+    enabled: false
     max_idle: 128
     idle_timeout: 30s
     max_lifetime: 2m