fix(rust): backdate extracted CLI mtime to stop self-invalidation

When `bundled-cli` is off, `build.rs` watches the extracted CLI binary via
`cargo:rerun-if-changed` so a deleted cache binary forces a re-extract. On a
cold cache the same build script *creates* that binary mid-build, after the
download — so its mtime ends up newer than cargo's build-script `output`
reference (stamped when the script was spawned). The next identical `cargo`
invocation then sees the watched file as "changed", reruns build.rs, recompiles
the SDK crate, and relinks every downstream crate (observed ~9 min of wasted CI
on a second cargo invocation in the same job).

Backdate the staged binary's mtime to the Unix epoch before the atomic rename
(rename preserves mtime), so it lands unambiguously older than any real build
reference and a no-change rebuild stays a true no-op. Best-effort: on error we
emit a `cargo:warning` and continue, reverting to the prior redundant-rebuild
behaviour rather than breaking the build. The deleted-file recovery contract is
untouched — a missing file still can't be stat'd, so cargo still reruns.

Embed mode (`bundled-cli` on) is unaffected: it emits no `rerun-if-changed` on
any build-created file.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: redsun82

rust/build.rs

@@ -378,6 +378,35 @@ fn extract_to_cache(archive: &[u8], install_dir: &Path, platform: Platform) -> P
         }
     }
 
+    // Backdate the staged binary to the Unix epoch before it lands. We emit
+    // `cargo:rerun-if-changed` on `final_path` (see caller) so a *deleted*
+    // cache binary forces a re-extract — but cargo stamps the build-script
+    // `output` reference when the script is spawned, seconds before this
+    // freshly-downloaded binary is written. A current mtime would therefore
+    // be *newer* than that reference, so the next identical `cargo`
+    // invocation would see the watched file as "changed" and pointlessly
+    // rerun build.rs + recompile the crate + relink every downstream crate.
+    // Pinning to the epoch keeps the file unambiguously older than any real
+    // build reference; `rename` preserves mtime (same inode), so it lands
+    // already-backdated and a no-change rebuild stays a true no-op. The
+    // deleted-file recovery contract is untouched: a missing file can't be
+    // stat'd, so cargo still treats it as stale and reruns regardless.
+    //
+    // Best-effort: a filesystem that refuses the epoch (e.g. FAT's 1980 floor
+    // clamps it — still older than any real reference) or rejects the call
+    // just reverts to the pre-fix redundant-rebuild behaviour, never a broken
+    // build.
+    if let Err(e) = std::fs::File::options()
+        .write(true)
+        .open(&staging_path)
+        .and_then(|f| f.set_modified(std::time::SystemTime::UNIX_EPOCH))
+    {
+        println!(
+            "cargo:warning=Could not backdate {} (a redundant rebuild may occur): {e}",
+            staging_path.display()
+        );
+    }
+
     // Atomic file-replace on both Unix and Windows. If a concurrent build
     // already produced the same file the rename overwrites it; the bytes
     // are SHA-verified-identical so replacement is safe.