perf: Parallelize package.json loading and reduce builder allocations (#11918)

## Summary

Parallelize the package.json loading phase and reduce allocations in the
package graph builder.

### Benchmarks (`--dry` runs, `--skip-infer`, 10 runs each, 5 warmup)

| Repo | Packages | Tasks | Before | After | Delta |
|------|----------|-------|--------|-------|-------|
| Large | ~1000 | 1690 | 2.107s ± 0.033s | 2.128s ± 0.203s | ~neutral
(noisy) |
| Medium | ~120 | ~200 | 1.292s ± 0.071s | 1.230s ± 0.078s | **1.05x
faster** |
| Small | ~5 | ~5 | 821.1ms ± 18.0ms | 812.7ms ± 15.6ms | **1.01x
faster** |

The medium repo shows the clearest improvement — it has enough packages
for rayon to help but isn't dominated by git subprocess overhead like
the large repo.

### Changes

**Parallel package.json loading**: `parse_package_jsons` previously
loaded and parsed each package.json file sequentially in a loop. Each
`PackageJson::load` call does disk I/O (`read_to_string`) and CPU-bound
JSON parsing (biome). These are independent per-package, so the loop is
replaced with `rayon::par_iter` to parallelize across all available
cores. The sequential `add_json` processing that mutates the builder is
unchanged.

**Entry API in `add_json`**: The old code called
`self.workspaces.insert(name.clone(), entry)` unconditionally, cloning
the `PackageName` on every call. On the error path (duplicate
workspace), it then did a second `get` + `clone` to retrieve the path.
Now uses `HashMap::entry()` to avoid the clone on the success path (only
clones once for `add_node`) and avoids the redundant lookup on the error
path.

**Capacity pre-allocation**: `workspaces` and `node_lookup` HashMaps are
now pre-allocated with `reserve(package_jsons.len())` before the
`add_json` loop, avoiding rehashing as entries are inserted.

Author: anthonyshew

Cargo.lock

@@ -23,6 +23,7 @@ lazy-regex = "2.5.0"
 miette = { workspace = true }
 node-semver = "2.2.0"
 petgraph = { workspace = true }
+rayon = "1"
 regex = { workspace = true }
 rust-ini = "0.20.0"
 serde = { workspace = true, features = ["derive"] }

crates/turborepo-repository/Cargo.toml

@@ -266,21 +266,23 @@ impl<'a, T: PackageDiscovery> BuildState<'a, ResolvedPackageManager, T> {
             package_json_path: relative_json_path,
             ..Default::default()
         };
-        if let Some(existing) = self.workspaces.insert(name.clone(), entry) {
-            let path = self
-                .workspaces
-                .get(&name)
-                .expect("just inserted entry to be present")
-                .package_json_path
-                .clone();
-            return Err(Error::DuplicateWorkspace {
-                name: name.to_string(),
-                path: path.to_string(),
-                existing_path: existing.package_json_path.to_string(),
-            });
+        match self.workspaces.entry(name) {
+            std::collections::hash_map::Entry::Vacant(vacant) => {
+                let name = vacant.key().clone();
+                vacant.insert(entry);
+                self.add_node(PackageNode::Workspace(name));
+                Ok(())
+            }
+            std::collections::hash_map::Entry::Occupied(occupied) => {
+                let existing_path = occupied.get().package_json_path.to_string();
+                let name = occupied.key().to_string();
+                Err(Error::DuplicateWorkspace {
+                    name,
+                    path: entry.package_json_path.to_string(),
+                    existing_path,
+                })
+            }
         }
-        self.add_node(PackageNode::Workspace(name));
-        Ok(())
     }
 
     // need our own type
@@ -293,15 +295,31 @@ impl<'a, T: PackageDiscovery> BuildState<'a, ResolvedPackageManager, T> {
         let package_jsons = match self.package_jsons.take() {
             Some(jsons) => Ok(jsons),
             None => {
-                let mut jsons = HashMap::new();
-                for path in self.package_discovery.discover_packages().await?.workspaces {
-                    let json = PackageJson::load(&path.package_json)?;
-                    jsons.insert(path.package_json, json);
+                let workspace_paths: Vec<_> =
+                    self.package_discovery.discover_packages().await?.workspaces;
+
+                let results: Vec<_> = {
+                    use rayon::prelude::*;
+                    workspace_paths
+                        .into_par_iter()
+                        .map(|path| {
+                            let json = PackageJson::load(&path.package_json)?;
+                            Ok((path.package_json, json))
+                        })
+                        .collect::<Result<Vec<_>, Error>>()?
+                };
+
+                let mut jsons = HashMap::with_capacity(results.len());
+                for (path, json) in results {
+                    jsons.insert(path, json);
                 }
                 Ok::<_, Error>(jsons)
             }
         }?;
 
+        self.workspaces.reserve(package_jsons.len());
+        self.node_lookup.reserve(package_jsons.len());
+
         for (path, json) in package_jsons {
             match self.add_json(path, json) {
                 Ok(()) => {}