feat: P3-T5 route resolution — find relay path to any fingerprint

RouteResolver queries PresenceRegistry to determine how to reach a target:
- Route::Local — connected to this relay
- Route::DirectPeer(addr) — on a directly connected peer relay
- Route::Chain(addrs) — multi-hop (structure ready, single-hop for now)
- Route::NotFound — not in any known relay

Protocol: added SignalMessage::RouteQuery { fingerprint, ttl } and
RouteResponse { fingerprint, found, relay_chain } for peer-to-peer
route queries over probe connections.

HTTP API: GET /route/:fingerprint returns JSON with route type + chain.

Relay handles incoming RouteQuery on probe connections: looks up locally,
replies with RouteResponse. TTL decremented for future multi-hop forwarding.

55 relay tests + 42 proto tests passing (7 new route tests).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

crates/wzp-relay/src/metrics.rs

@@ -201,18 +201,20 @@ impl RelayMetrics {
     }
 }
 
-/// Start an HTTP server serving GET /metrics, GET /mesh, and presence endpoints on the given port.
+/// Start an HTTP server serving GET /metrics, GET /mesh, presence, and route endpoints on the given port.
 pub async fn serve_metrics(
     port: u16,
     metrics: Arc<RelayMetrics>,
     presence: Option<Arc<tokio::sync::Mutex<crate::presence::PresenceRegistry>>>,
+    route_resolver: Option<Arc<crate::route::RouteResolver>>,
 ) {
     use axum::{extract::Path, routing::get, Router};
 
     let metrics_clone = metrics.clone();
     let presence_all = presence.clone();
     let presence_lookup = presence.clone();
-    let presence_peers = presence;
+    let presence_peers = presence.clone();
+    let presence_route = presence;
 
     let app = Router::new()
         .route(
@@ -288,6 +290,32 @@ pub async fn serve_metrics(
                     }
                 }
             }),
+        )
+        .route(
+            "/route/:fingerprint",
+            get(move |Path(fingerprint): Path<String>| {
+                let reg = presence_route.clone();
+                let resolver = route_resolver.clone();
+                async move {
+                    match (reg, resolver) {
+                        (Some(r), Some(res)) => {
+                            let r = r.lock().await;
+                            let route = res.resolve(&r, &fingerprint);
+                            let json = res.route_json(&fingerprint, &route);
+                            serde_json::to_string_pretty(&json)
+                                .unwrap_or_else(|_| "{}".to_string())
+                        }
+                        _ => {
+                            serde_json::json!({
+                                "fingerprint": fingerprint,
+                                "route": "not_found",
+                                "relay_chain": [],
+                            })
+                            .to_string()
+                        }
+                    }
+                }
+            }),
         );
 
     let addr = std::net::SocketAddr::from(([0, 0, 0, 0], port));