perf: Race parallel git subprocesses against filesystem walk for optimal index construction (#12206)

## Summary

- Replaces `new_from_gix_index` (stat every tracked file) +
`walk_candidate_files` with a faster hybrid approach
- Uses `git ls-tree` + `git diff-index` subprocesses for the tracked
index (simpler, fast everywhere)
- **Races** `walk_candidate_files` (8-thread ignore-crate walk) against
`git ls-files --others` (git subprocess) for untracked file discovery —
whichever finishes first wins
- The race guarantees optimal performance on every platform without
platform-specific code paths

## Why

No single untracked-file discovery method is fastest everywhere:

| Method | macOS APFS | Linux ext4 |
|---|---|---|
| `walk_candidate_files` (8 threads) | **~440ms** | ~474ms |
| `git ls-files --others` (single thread) | ~530ms | **~231ms** |

Racing both and using the winner eliminates regressions on either
platform.

## How the race works

Four operations spawn on separate threads:
1. `git ls-tree -r HEAD -z` — blob OIDs (~60-110ms)
2. `git diff-index HEAD -z` — modified/deleted (~95-150ms)
3. `walk_candidate_files` — 8-thread filesystem walk
4. `git ls-files --others -z` — git subprocess

Operations 3 and 4 send results through an `mpsc` channel. The first
result wins. The losing thread runs to completion and its result is
discarded.

If `ls-files` wins: its output is the untracked file list directly.
If `walk` wins: candidates are filtered against `ls-tree` hashes to find
untracked files.

## Benchmark (110-package monorepo, 30 runs, sandboxed Linux)

| | Mean | Min | Max |
|---|---|---|---|
| Baseline (main) | 878ms ± 27ms | 840ms | 953ms |
| This PR | **437ms ± 7ms** | 427ms | 455ms |

**2.01x faster** on Linux. No regression on macOS (walk wins the race at
~440ms, same as the split-walk approach).

## Test Coverage

18 new regression tests across three categories:

**Category 7 — Ground truth** (8 tests): Establish correct per-package
hashes across edge cases (staged changes/new files/deletions, unstaged
modifications, no-commit repos, comprehensive mixed state).

**Category 8 — Subprocess+race equivalence** (5 tests): Verify the
race-based constructor produces identical results to gix-index and
no-index paths.

**Category 9 — Race arm equivalence** (5 tests): Independently verify
each arm of the race (walk path and ls-files path) produces identical
results, so the winner is always correct regardless of which arm wins.

## How to Review

1. `repo_index.rs` — `new_from_subprocess_and_walk`: the race
implementation with `mpsc` channel
2. `ls_tree.rs` — `git_ls_tree_repo_root_sorted`,
`git_diff_index_repo_root`, `git_ls_files_untracked` + parsers
3. `lib.rs` — `build_repo_index_from_subprocesses` accepts prefixes,
calls new constructor
4. `builder.rs` — Passes `all_package_prefixes` into the method
5. `git_index_regression_tests.rs` — `build_walk_arm_index`,
`build_ls_files_arm_index` helpers + 18 new tests

Author: anthonyshew

crates/turborepo-lib/src/run/builder.rs

@@ -261,24 +261,12 @@ impl RunBuilder {
         );
         let start_at = Local::now();
 
-        let (tracked_index_tx, tracked_index_rx) =
-            tokio::sync::oneshot::channel::<Option<turborepo_scm::RepoGitIndex>>();
-        let (git_root_tx, git_root_rx) =
-            tokio::sync::oneshot::channel::<Option<turbopath::AbsoluteSystemPathBuf>>();
         let scm_task = {
             let repo_root = self.repo_root.clone();
             let git_root = self.opts.git_root.clone();
-            tokio::task::spawn_blocking(move || {
-                let scm = match git_root {
-                    Some(root) => SCM::new_with_git_root(&repo_root, root),
-                    None => SCM::new(&repo_root),
-                };
-                // Send git root immediately so the filesystem walk can start
-                // while index construction continues.
-                let _ = git_root_tx.send(scm.git_root().map(|r| r.to_owned()));
-                let repo_index = scm.build_tracked_repo_index_eager();
-                let _ = tracked_index_tx.send(repo_index);
-                scm
+            tokio::task::spawn_blocking(move || match git_root {
+                Some(root) => SCM::new_with_git_root(&repo_root, root),
+                None => SCM::new(&repo_root),
             })
         };
         let package_json_path = self.repo_root.join_component("package.json");
@@ -354,39 +342,24 @@ impl RunBuilder {
         repo_telemetry.track_size(pkg_dep_graph.len());
         run_telemetry.track_run_type(self.opts.run_opts.dry_run.is_some());
 
-        // Spawn the filesystem walk as soon as the git root is resolved.
-        // It only needs the git root and package prefixes, not the tracked
-        // index. The walk runs in parallel with new_from_gix_index (~267ms).
+        // Build the repo index using parallel git subprocesses for the tracked
+        // index (ls-tree + diff-index) and a race between walk_candidate_files
+        // and git ls-files for untracked discovery. The race ensures optimal
+        // performance: the walk wins on macOS, ls-files wins on Linux.
         let all_prefixes = Self::all_package_prefixes(&pkg_dep_graph);
-        let walk_task = if all_prefixes.is_empty() {
+        let scm = scm_task
+            .instrument(tracing::info_span!("scm_task_await"))
+            .await
+            .expect("detecting scm panicked");
+        let repo_index_task = if all_prefixes.is_empty() {
             None
         } else {
-            Some(tokio::task::spawn(async move {
-                let git_root = match git_root_rx.await {
-                    Ok(Some(root)) => root,
-                    _ => return None,
-                };
-                tokio::task::spawn_blocking(move || {
-                    let _span = tracing::info_span!("walk_candidate_files").entered();
-                    turborepo_scm::walk_candidate_files(git_root.as_std_path(), Some(&all_prefixes))
-                        .ok()
-                })
-                .await
-                .ok()?
+            let scm = scm.clone();
+            Some(tokio::task::spawn_blocking(move || {
+                let _span = tracing::info_span!("build_repo_index_subprocesses").entered();
+                scm.build_repo_index_from_subprocesses(&all_prefixes)
             }))
         };
-
-        // Combine the walk results with the tracked index once both are ready.
-        let repo_index_task = walk_task.map(|walk_task| {
-            tokio::task::spawn(async move {
-                let (candidates, tracked_index) = tokio::join!(walk_task, tracked_index_rx);
-                let candidates = candidates.ok()??;
-                let tracked_index = tracked_index.ok()??;
-                let mut repo_index = tracked_index;
-                repo_index.populate_untracked_from_candidates(candidates);
-                Some(repo_index)
-            })
-        });
         let micro_frontend_configs = {
             let _span = tracing::info_span!("micro_frontends_from_disk").entered();
             match MicrofrontendsConfigs::from_disk(&self.repo_root, &pkg_dep_graph) {
@@ -497,13 +470,6 @@ impl RunBuilder {
             turbo_json_loader.preload_all();
         }
 
-        // Await the SCM background task. The tracked index was already
-        // forwarded to the untracked walk via oneshot channel above.
-        let scm = scm_task
-            .instrument(tracing::info_span!("scm_task_await"))
-            .await
-            .expect("detecting scm panicked");
-
         let filtered_pkgs = {
             let _span = tracing::info_span!("calculate_filtered_packages").entered();
             Self::calculate_filtered_packages(