feat(server): add random DID sampling endpoint

Implement new /random endpoint to sample random DIDs with configurable count and seed parameters. The endpoint returns JSON response containing sampled DIDs, count and seed used for reproducibility.

src/server/handle_random.rs

···
+use crate::server::ServerState;
+use crate::server::error::{bad_request, internal_error, task_join_error};
+use axum::{
+    extract::{Query, State},
+    http::StatusCode,
+    response::IntoResponse,
+};
+use serde::Deserialize;
+use serde_json::json;
+use std::sync::Arc;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+#[derive(Deserialize)]
+pub struct RandomQuery {
+    pub count: Option<usize>,
+    pub seed: Option<u64>,
+}
+
+pub async fn handle_random_dids(
+    State(state): State<ServerState>,
+    Query(params): Query<RandomQuery>,
+) -> impl IntoResponse {
+    let count = params.count.unwrap_or(10);
+    if count > 1000 {
+        return bad_request("count must be <= 1000").into_response();
+    }
+    let effective_seed = params
+        .seed
+        .unwrap_or_else(|| {
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap()
+                .as_nanos() as u64
+        });
+    if count == 0 {
+        return (
+            StatusCode::OK,
+            axum::Json(json!({ "dids": [], "count": 0, "seed": effective_seed })),
+        )
+            .into_response();
+    }
+
+    let dids = match tokio::task::spawn_blocking({
+        let manager = Arc::clone(&state.manager);
+        move || manager.sample_random_dids(count, Some(effective_seed))
+    })
+    .await
+    {
+        Ok(Ok(list)) => list,
+        Ok(Err(e)) => return internal_error(&e.to_string()).into_response(),
+        Err(e) => return task_join_error(e).into_response(),
+    };
+
+    (StatusCode::OK, axum::Json(json!({
+        "dids": dids,
+        "count": count,
+        "seed": effective_seed
+    })))
+        .into_response()
+}

src/server/handle_root.rs

···
     response.push_str("  GET  /op/:pointer         Get single operation\n");
     response.push_str("  GET  /status              Server status\n");
     response.push_str("  GET  /mempool             Mempool operations (JSONL)\n");
+    response.push_str("  GET  /random              Random DID sample (JSON)\n");
 
     if state.config.enable_websocket {
         response.push_str("\nWebSocket Endpoints\n");
···
     ));
     response.push_str(&format!("  curl {}/jsonl/1\n", base_url));
     response.push_str(&format!("  curl {}/op/0\n", base_url));
+    response.push_str(&format!("  curl {}/random?count=10&seed=12345\n", base_url));
 
     if state.config.sync_mode {
         response.push_str(&format!("  curl {}/status\n", base_url));

src/server/mod.rs

···
 #[cfg(feature = "server")]
 mod handle_did;
 #[cfg(feature = "server")]
+mod handle_random;
+#[cfg(feature = "server")]
 mod handle_root;
 #[cfg(feature = "server")]
 mod handle_status;
···
 pub use handle_debug::*;
 #[cfg(feature = "server")]
 pub use handle_did::*;
+#[cfg(feature = "server")]
+pub use handle_random::*;
 #[cfg(feature = "server")]
 pub use handle_root::*;
 #[cfg(feature = "server")]

src/server/routes.rs

···
 use crate::server::{
     handle_bundle, handle_bundle_data, handle_bundle_jsonl, handle_debug_didindex,
     handle_debug_memory, handle_debug_resolver, handle_did_routing_guard, handle_index_json,
-    handle_mempool, handle_operation, handle_root, handle_status,
+    handle_mempool, handle_operation, handle_random_dids, handle_root, handle_status,
 };
 use axum::Router;
 use std::sync::Arc;
···
         .route("/op/{pointer}", axum::routing::get(handle_operation))
         .route("/status", axum::routing::get(handle_status))
         .route("/mempool", axum::routing::get(handle_mempool))
+        .route("/random", axum::routing::get(handle_random_dids))
         .route("/debug/memory", axum::routing::get(handle_debug_memory))
         .route("/debug/didindex", axum::routing::get(handle_debug_didindex))
         .route("/debug/resolver", axum::routing::get(handle_debug_resolver));