clippy: fix lints that crane's cargoClippy properly enforces (#538)

The naersk → crane swap in the parent commit flips clippy from
silently passing to actually failing on `-D warnings` (naersk's
`mode = "clippy"` mangled the `--` separator so the deny never took
effect). This commit clears the surfaced lints so the workspace
builds clean under the new enforcement — every fix is mechanical and
preserves behaviour. Tests still pass (160 across the workspace).

Auto-fixes via `cargo clippy --fix`:
- `doc_markdown` (19 sites): bare identifiers in doc comments
  wrapped in backticks
- `format_in_format_args`, `explicit_into_iter_loop`,
  `redundant_closure_for_method_calls`, `useless_conversion`, and
  a few more — mechanical rewrites of the kind cargo can apply
  safely.

Hand-fixed:
- `match_same_arms` (forge_notify::is_atx_heading): two arms returning
  `true` collapsed into a single `matches!` pattern.
- `cast_sign_loss` + `format_push_string` (mcp.rs status formatter):
  guarded `i64 → u64` through `u64::try_from(…).unwrap_or(0)` (status
  timestamps are always positive in practice; clamp the skew edge to
  0) and swapped `out.push_str(&format!(…))` for `write!` into the
  buffer with an infallible-writer `let _ =`.
- `doc_lazy_continuation` in turn.rs + manager_server.rs + sh4re/lib.rs:
  doc paragraphs that the markdown parser was treating as list-item
  continuations got either a separating blank line or a `/`-for-`+`
  word swap so the parser stops seeing a list.
- `unused_async` (manager_server::handle_request_schedule_prompt):
  function has no `.await`; dropped the `async` and its `.await` call
  site.
- `needless_pass_by_value` (scheduled_prompts::submit): take
  `&NewSchedule` instead of moving the struct in; updated two prod
  callers and eight test sites to pass references.
- `type_complexity` (approvals::mark_cancelled): hoisted the
  7-tuple SELECT row shape into a `type CancelLookupRow = (…);` alias.

Allow-with-reason for intentional patterns:
- `option_option` (6 sites across dashboard / scheduled_prompts /
  manager_server): `Option<Option<T>>` carries three-state PATCH
  semantics (missing key = leave alone, `Some(None)` = clear,
  `Some(Some(v))` = set). Collapsing to `Option<T>` loses the
  "clear" state.
- `dead_code` (rebuild_queue::QueueKind::Destroy /
  QueueSource::CrashRecover; topology::parent_of / default_seed):
  wire-shape variants + API surfaces kept for the upcoming features
  (#361 follow-ups, future `Destroy` queue routing, crash-recovery
  path). Allowed at the variant / function level with the rationale
  in `reason = "…"`.
- `too_many_lines` on three specific call-sites: a 117-line
  exhaustive-variant test (dashboard_events::kind_tag_matches_…),
  the meta-flake string template renderer
  (meta::render_flake_with_lookup), and the notification poll loop
  (forge_notify::poll_once) — splitting any of them would just hide
  the contiguous shape they exist to keep visible.

`nix flake check` formatting target is still broken on main itself
(pre-existing nixfmt drift across ~28 files unrelated to this PR);
left alone here so the scope stays "crane port + lints the port
exposed" and the operator's review doesn't have to triage drive-by
nixfmt churn.

hive-c0re/src/manager_server.rs

@@ -90,7 +90,11 @@ fn manager_recv_timeout(wait_seconds: Option<u64>) -> std::time::Duration {
 #[allow(clippy::too_many_lines)]
 async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResponse {
     match req {
-        ManagerRequest::Send { to, body, in_reply_to } => {
+        ManagerRequest::Send {
+            to,
+            body,
+            in_reply_to,
+        } => {
             if let Err(message) = crate::limits::check_size("send", body) {
                 return ManagerResponse::Err { message };
             }
@@ -195,7 +199,14 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
             ) {
                 Ok(id) => {
                     tracing::info!(%id, %name, "init_config approval queued");
-                    coord.emit_approval_added(id, name, "init_config", None, None, description.clone());
+                    coord.emit_approval_added(
+                        id,
+                        name,
+                        "init_config",
+                        None,
+                        None,
+                        description.clone(),
+                    );
                     ManagerResponse::Ok
                 }
                 Err(e) => ManagerResponse::Err {
@@ -302,7 +313,7 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
                 Err(e) => {
                     return ManagerResponse::Err {
                         message: format!("queue update_meta_inputs approval: {e:#}"),
-                    }
+                    };
                 }
             };
             tracing::info!(%id, %label, "update_meta_inputs approval queued");
@@ -317,7 +328,7 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
             ManagerResponse::Ok
         }
         ManagerRequest::RequestSchedulePrompt(payload) => {
-            handle_request_schedule_prompt(coord, hive_sh4re::MANAGER_AGENT, payload).await
+            handle_request_schedule_prompt(coord, hive_sh4re::MANAGER_AGENT, payload)
         }
         ManagerRequest::CancelSchedule { id, targets } => {
             handle_cancel_schedule(coord, hive_sh4re::MANAGER_AGENT, *id, targets.as_deref())
@@ -482,12 +493,13 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
         ManagerRequest::SetStatus { text } => {
             let path = Coordinator::agent_notes_dir(MANAGER_AGENT).join("hyperhive-status");
             let result = if text.trim().is_empty() {
-                std::fs::remove_file(&path)
-                    .or_else(|e| if e.kind() == std::io::ErrorKind::NotFound {
+                std::fs::remove_file(&path).or_else(|e| {
+                    if e.kind() == std::io::ErrorKind::NotFound {
                         Ok(())
                     } else {
                         Err(e)
-                    })
+                    }
+                })
             } else {
                 std::fs::write(&path, format!("{}\n", text.trim()))
             };
@@ -497,7 +509,9 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
                     tokio::spawn(async move { coord2.rescan_containers_and_emit().await });
                     ManagerResponse::Ok
                 }
-                Err(e) => ManagerResponse::Err { message: format!("set_status write failed: {e}") },
+                Err(e) => ManagerResponse::Err {
+                    message: format!("set_status write failed: {e}"),
+                },
             }
         }
         ManagerRequest::GetAgentMeta { name } => {
@@ -508,7 +522,12 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
             // tell (e.g. "iris is down" vs "iris has no status set").
             let (status_text, status_set_at, running) =
                 crate::container_view::read_agent_status_live(target).await;
-            let role = if target == MANAGER_AGENT { "manager" } else { "agent" }.to_owned();
+            let role = if target == MANAGER_AGENT {
+                "manager"
+            } else {
+                "agent"
+            }
+            .to_owned();
             ManagerResponse::AgentMeta {
                 name: target.to_owned(),
                 role,
@@ -518,16 +537,12 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
                 status_set_at,
             }
         }
-        ManagerRequest::CancelLooseEnd { kind, id } => crate::questions::handle_cancel_loose_end(
-            coord,
-            MANAGER_AGENT,
-            *kind,
-            *id,
-        )
-        .map_or_else(
-            |message| ManagerResponse::Err { message },
-            |()| ManagerResponse::Ok,
-        ),
+        ManagerRequest::CancelLooseEnd { kind, id } => {
+            crate::questions::handle_cancel_loose_end(coord, MANAGER_AGENT, *kind, *id).map_or_else(
+                |message| ManagerResponse::Err { message },
+                |()| ManagerResponse::Ok,
+            )
+        }
         ManagerRequest::AckTurn => match coord.broker.ack_turn(MANAGER_AGENT) {
             Ok(_n) => ManagerResponse::Ok,
             Err(e) => ManagerResponse::Err {
@@ -706,7 +721,7 @@ async fn submit_apply_commit(
 /// inputs (non-empty targets, non-empty body, sane interval) at
 /// submit time — the operator should never see a malformed schedule
 /// pending approval.
-async fn handle_request_schedule_prompt(
+fn handle_request_schedule_prompt(
     coord: &Arc<Coordinator>,
     requester: &str,
     payload: &hive_sh4re::SchedulePromptPayload,
@@ -731,7 +746,7 @@ async fn handle_request_schedule_prompt(
         Err(e) => {
             return ManagerResponse::Err {
                 message: format!("encode SchedulePromptPayload: {e:#}"),
-            }
+            };
         }
     };
     let id = match coord.approvals.submit_kind(
@@ -744,7 +759,7 @@ async fn handle_request_schedule_prompt(
         Err(e) => {
             return ManagerResponse::Err {
                 message: format!("queue schedule_prompt approval: {e:#}"),
-            }
+            };
         }
     };
     tracing::info!(
@@ -783,12 +798,12 @@ fn handle_cancel_schedule(
         Ok(None) => {
             return ManagerResponse::Err {
                 message: format!("schedule {schedule_id} not found"),
-            }
+            };
         }
         Err(e) => {
             return ManagerResponse::Err {
                 message: format!("read schedule {schedule_id}: {e:#}"),
-            }
+            };
         }
     };
     if !cancel_authorized(requester, &schedule.owner) {
@@ -830,12 +845,12 @@ async fn handle_fire_schedule_now(
         Ok(None) => {
             return ManagerResponse::Err {
                 message: format!("schedule {schedule_id} not found"),
-            }
+            };
         }
         Err(e) => {
             return ManagerResponse::Err {
                 message: format!("read schedule {schedule_id}: {e:#}"),
-            }
+            };
         }
     };
     if !cancel_authorized(requester, &schedule.owner) {
@@ -858,11 +873,16 @@ async fn handle_fire_schedule_now(
 /// ownership rules as `CancelSchedule` — the manager can edit
 /// schedules it owns + any owned by an agent in its subtree.
 /// Forwards the partial payload to
-/// `ScheduledPrompts::update` which enforces the cancelled-row
-/// + zero-interval validation. Returns `Ok` on a clean update;
+/// `ScheduledPrompts::update` which enforces the cancelled-row /
+/// zero-interval validation. Returns `Ok` on a clean update;
 /// `Err` with the underlying message on any auth / validation
 /// failure so the dashboard can surface it verbatim.
 #[allow(clippy::too_many_arguments)]
+#[allow(
+    clippy::option_option,
+    reason = "double-Option carries three-state PATCH semantics: outer None = \
+              leave alone, Some(None) = clear, Some(Some(v)) = set"
+)]
 fn handle_edit_schedule(
     coord: &Arc<Coordinator>,
     requester: &str,
@@ -879,12 +899,12 @@ fn handle_edit_schedule(
         Ok(None) => {
             return ManagerResponse::Err {
                 message: format!("schedule {schedule_id} not found"),
-            }
+            };
         }
         Err(e) => {
             return ManagerResponse::Err {
                 message: format!("read schedule {schedule_id}: {e:#}"),
-            }
+            };
         }
     };
     if !cancel_authorized(requester, &schedule.owner) {