feat(serve): registry names + docs (v0.2 chunk 4)

Registration:
- Each listener registers "urus.listener.{i}" from inside its ChildSpec
  factory. On a restart the stale binding points at a dead pid; smarm's
  registry evicts those lazily on register/whereis, so re-registering
  the same name is safe. Result ignored — a registry hiccup must not
  take the listener down.
- "urus.server" -> supervisor pid, registered via the JoinHandle's
  .pid() immediately after spawn rather than inside the closure: the
  binding exists before the supervisor runs an instruction, so an early
  whereis can't observe None.

Test: server_and_listeners_are_registered probes whereis from a route
handler — whereis must run inside the runtime, and the test thread is a
foreign OS thread with no runtime in its TLS.

Docs:
- README: Config documented in full (timeout semantics: keep_alive =
  idle-before-first-byte, request = Instant deadline first-byte ->
  head+body, slowloris-proof), Handle/shutdown_handle/serve_with_shutdown
  section with the 4-step shutdown sequence, named-actors note, test
  coverage list refreshed, Roadmap section now points at ROADMAP.md.
- ROADMAP: v0.2 chunks 1-4 marked landed; design detail stays in the
  chunk commit bodies.

Verified: cargo build --features smarm-trace clean; full suite (32
tests) green 3x; debug-grep clean.

This closes v0.2. Exit criteria all verified across chunks 1-3: crud
drains on stdin-Enter (~100ms), idle keep-alive reaped at
keep_alive_timeout, panicking listener restarts under load.

tests/integration.rs

@@ -89,6 +89,25 @@ fn hello_world() {
     assert_eq!(http_body(&resp), b"hello urus");
 }
 
+#[test]
+fn server_and_listeners_are_registered() {
+    // `whereis` must run inside the runtime (the test itself is a foreign
+    // OS thread with no runtime in its TLS), so probe from a handler —
+    // connection actors live in the runtime by construction.
+    let pipe = Pipeline::new().plug(
+        Router::new().get("/whereis", |c: Conn, _n: Next| {
+            let ok = smarm::whereis("urus.server").is_some()
+                && smarm::whereis("urus.listener.0").is_some()
+                && smarm::whereis("urus.listener.1").is_some(); // pool of 2
+            c.put_status(200).put_body(if ok { "registered" } else { "missing" })
+        })
+    );
+    let port = spawn_server(pipe);
+    let resp = send_request(port, b"GET /whereis HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n");
+    assert_eq!(http_status(&resp), 200);
+    assert_eq!(http_body(&resp), b"registered");
+}
+
 #[test]
 fn echo_body() {
     let pipe = Pipeline::new().plug(