chore(v1.1.9): clippy clean — workspace -D warnings

Surfaced + fixed during the F3 attestation:

- executor-core/sdk/queue.rs: drop redundant .map(|()| ()) call sites;
  enqueue_blocking discards QueueMessageId via .map(|_id| ()) (intentional)
- executor-core/sdk/retry.rs: hoist use std::collections::hash_map::DefaultHasher
  + use std::hash::Hasher to the top of the file (clippy::items_after_statements);
  replace `as i64` casts with i64::try_from + clear comment about jitter
  bound (clippy::cast_possible_wrap)
- executor-core/sdk/invoke.rs: move _LIMITS_IS_COPY const before #[cfg(test)]
  mod tests (clippy::items_after_test_module)
- manager-core/dispatcher.rs: dispatch_one_queue gains #[allow(too_many_lines)]
  (it's the queue tick's whole logic — split makes it less readable than
  the lint); .map(...).unwrap_or(default) → .map_or(default, ...)
- picloud/lib.rs: Limits { trigger_depth_max, ..Limits::default() } via
  struct-update instead of let-mut-assign (clippy::field_reassign_with_default)
- tests: r#"..."# → r"..." where there are no `"` inside (clippy::needless_raw_string_hashes);
  combine InvokeTarget::Name | InvokeTarget::Path arms with identical bodies
  in sdk_invoke.rs (clippy::match_same_arms)

cargo fmt --all -- --check 2>&1 | tail -3: no output (exit 0)
cargo clippy --workspace --all-targets --all-features -- -D warnings:
  Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.41s
Workspace lib smoke: 432 passing (306 manager-core + 74 executor-core + 34 shared + 18 orchestrator-core).
DB-gated E2E (against docker compose postgres on localhost:15432):
  queue_e2e: 4 ok / invoke_e2e: 4 ok / retry_e2e: 3 ok / migration_queue_messages: 4 ok / schema_snapshot: 1 ok

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

crates/picloud/tests/queue_e2e.rs

@@ -127,14 +127,13 @@ async fn poll_marker(pool: &PgPool, app_id: &str) -> Option<Value> {
 }
 
 async fn count_queue_messages(pool: &PgPool, app_id: &str, queue: &str) -> i64 {
-    let (n,): (i64,) = sqlx::query_as(
-        "SELECT COUNT(*) FROM queue_messages WHERE app_id = $1 AND queue_name = $2",
-    )
-    .bind(Uuid::parse_str(app_id).expect("uuid"))
-    .bind(queue)
-    .fetch_one(pool)
-    .await
-    .expect("queue count");
+    let (n,): (i64,) =
+        sqlx::query_as("SELECT COUNT(*) FROM queue_messages WHERE app_id = $1 AND queue_name = $2")
+            .bind(Uuid::parse_str(app_id).expect("uuid"))
+            .bind(queue)
+            .fetch_one(pool)
+            .await
+            .expect("queue count");
     n
 }
 
@@ -170,7 +169,9 @@ async fn enqueue_directly(pool: &PgPool, app_id: &str, queue: &str, payload: Val
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn queue_receive_acks_on_success() {
-    let Some(pool) = pool_or_skip().await else { return };
+    let Some(pool) = pool_or_skip().await else {
+        return;
+    };
     let (server, app_id) = server_for(pool.clone(), "ack").await;
 
     let script_id = create_script(&server, &app_id, "worker", ACK_HANDLER).await;
@@ -186,9 +187,7 @@ async fn queue_receive_acks_on_success() {
 
     enqueue_directly(&pool, &app_id, "jobs", json!({ "x": 42 })).await;
 
-    let marker = poll_marker(&pool, &app_id)
-        .await
-        .expect("handler fired");
+    let marker = poll_marker(&pool, &app_id).await.expect("handler fired");
     assert_eq!(marker["source"], "queue");
     assert_eq!(marker["queue"]["queue_name"], "jobs");
     assert_eq!(marker["queue"]["message"]["x"], 42);
@@ -199,7 +198,9 @@ async fn queue_receive_acks_on_success() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn queue_receive_dead_letters_after_max_attempts() {
-    let Some(pool) = pool_or_skip().await else { return };
+    let Some(pool) = pool_or_skip().await else {
+        return;
+    };
     let (server, app_id) = server_for(pool.clone(), "dl").await;
 
     let script_id = create_script(&server, &app_id, "fail", THROW_HANDLER).await;
@@ -236,7 +237,9 @@ async fn queue_receive_dead_letters_after_max_attempts() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn queue_one_consumer_per_queue_rejected() {
-    let Some(pool) = pool_or_skip().await else { return };
+    let Some(pool) = pool_or_skip().await else {
+        return;
+    };
     let (server, app_id) = server_for(pool.clone(), "onecon").await;
 
     let s1 = create_script(&server, &app_id, "first", ACK_HANDLER).await;
@@ -276,7 +279,9 @@ async fn queue_one_consumer_per_queue_rejected() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn queue_visibility_timeout_reclaim() {
-    let Some(pool) = pool_or_skip().await else { return };
+    let Some(pool) = pool_or_skip().await else {
+        return;
+    };
     let (server, app_id) = server_for(pool.clone(), "vt").await;
 
     let script_id = create_script(&server, &app_id, "slow", ACK_HANDLER).await;
@@ -317,13 +322,12 @@ async fn queue_visibility_timeout_reclaim() {
     // Otherwise the reclaim path is the only way the message would
     // have been picked up. Poll the claim state.
     for _ in 0..50 {
-        let row: Option<(Option<Uuid>,)> = sqlx::query_as(
-            "SELECT claim_token FROM queue_messages WHERE id = $1",
-        )
-        .bind(msg_id)
-        .fetch_optional(&pool)
-        .await
-        .expect("read");
+        let row: Option<(Option<Uuid>,)> =
+            sqlx::query_as("SELECT claim_token FROM queue_messages WHERE id = $1")
+                .bind(msg_id)
+                .fetch_optional(&pool)
+                .await
+                .expect("read");
         if let Some((token,)) = row {
             if token.is_none() {
                 return; // reclaim succeeded — claim cleared