perf: Replace O(N) workspace path lookup with HashMap index in DependencySplitter (#11922)

## Summary

`DependencySplitter::workspace()` did a linear scan over all workspaces
to find a package by its directory path. This is called for every
`workspace:` path-based dependency during
`connect_internal_dependencies` — O(N) per lookup, O(N²) total for repos
using path-based workspace protocol references (e.g.
`workspace:../sibling-pkg`).

Adds `WorkspacePathIndex` — a `HashMap<&AnchoredSystemPath,
&PackageName>` built once before the dependency resolution loop and
shared across all `DependencySplitter` instances. Lookups go from O(N)
linear scan to O(1).

### Changes

**`dep_splitter.rs`**: New `WorkspacePathIndex` struct built from the
workspaces HashMap. `DependencySplitter::new` takes a shared
`&WorkspacePathIndex` reference. `workspace()` uses an O(1) HashMap
lookup instead of `iter().find()`.

**`builder.rs`**: `connect_internal_dependencies` builds the
`WorkspacePathIndex` once before the loop. `Dependencies::new` passes it
through to the splitter.

Author: anthonyshew

crates/turborepo-repository/src/package_graph/builder.rs

@@ -10,7 +10,8 @@ use turborepo_graph_utils as graph;
 use turborepo_lockfiles::Lockfile;
 
 use super::{
-    PackageGraph, PackageInfo, PackageName, PackageNode, dep_splitter::DependencySplitter,
+    PackageGraph, PackageInfo, PackageName, PackageNode,
+    dep_splitter::{DependencySplitter, WorkspacePathIndex},
 };
 use crate::{
     discovery::{
@@ -392,6 +393,7 @@ impl<'a, T: PackageDiscovery> BuildState<'a, ResolvedWorkspaces, T> {
         &mut self,
         package_manager: &PackageManager,
     ) -> Result<(), Error> {
+        let path_index = WorkspacePathIndex::new(&self.workspaces);
         let split_deps = self
             .workspaces
             .iter()
@@ -405,6 +407,7 @@ impl<'a, T: PackageDiscovery> BuildState<'a, ResolvedWorkspaces, T> {
                         &self.workspaces,
                         package_manager,
                         entry.package_json.all_dependencies(),
+                        &path_index,
                     ),
                 )
             })
@@ -601,15 +604,21 @@ impl Dependencies {
         workspaces: &HashMap<PackageName, PackageInfo>,
         package_manager: &PackageManager,
         dependencies: I,
+        path_index: &WorkspacePathIndex<'_>,
     ) -> Self {
         let resolved_workspace_json_path = repo_root.resolve(workspace_json_path);
         let workspace_dir = resolved_workspace_json_path
             .parent()
             .expect("package.json path should have parent");
         let mut internal = HashSet::new();
         let mut external = BTreeMap::new();
-        let splitter =
-            DependencySplitter::new(repo_root, workspace_dir, workspaces, package_manager);
+        let splitter = DependencySplitter::new(
+            repo_root,
+            workspace_dir,
+            workspaces,
+            package_manager,
+            path_index,
+        );
         for (name, version) in dependencies.into_iter() {
             if let Some(workspace) = splitter.is_internal(name, version) {
                 internal.insert(workspace);

crates/turborepo-repository/src/package_graph/dep_splitter.rs

@@ -8,10 +8,26 @@ use turbopath::{
 use super::{PackageInfo, PackageName};
 use crate::package_manager::PackageManager;
 
+/// Reverse index from package path to package name, built once and shared
+/// across all `DependencySplitter` instances.
+pub struct WorkspacePathIndex<'a>(HashMap<&'a AnchoredSystemPath, &'a PackageName>);
+
+impl<'a> WorkspacePathIndex<'a> {
+    pub fn new(workspaces: &'a HashMap<PackageName, PackageInfo>) -> Self {
+        Self(
+            workspaces
+                .iter()
+                .map(|(name, info)| (info.package_path(), name))
+                .collect(),
+        )
+    }
+}
+
 pub struct DependencySplitter<'a> {
     repo_root: &'a AbsoluteSystemPath,
     workspace_dir: &'a AbsoluteSystemPath,
     workspaces: &'a HashMap<PackageName, PackageInfo>,
+    path_index: &'a WorkspacePathIndex<'a>,
     link_workspace_packages: bool,
 }
 
@@ -21,12 +37,14 @@ impl<'a> DependencySplitter<'a> {
         workspace_dir: &'a AbsoluteSystemPath,
         workspaces: &'a HashMap<PackageName, PackageInfo>,
         package_manager: &PackageManager,
+        path_index: &'a WorkspacePathIndex<'a>,
     ) -> Self {
         let link_workspace_packages = package_manager.link_workspace_packages(repo_root);
         Self {
             repo_root,
             workspace_dir,
             workspaces,
+            path_index,
             link_workspace_packages,
         }
     }
@@ -86,9 +104,9 @@ impl<'a> DependencySplitter<'a> {
     }
 
     fn workspace(&self, path: &AnchoredSystemPath) -> Option<(&PackageName, &PackageInfo)> {
-        self.workspaces
-            .iter()
-            .find(|(_, info)| info.package_path() == path)
+        let name = self.path_index.0.get(path)?;
+        let info = self.workspaces.get(name)?;
+        Some((name, info))
     }
 }
 
@@ -305,10 +323,12 @@ mod test {
             map
         };
 
+        let path_index = WorkspacePathIndex::new(&workspaces);
         let splitter = DependencySplitter {
             repo_root: &root,
             workspace_dir: &pkg_dir,
             workspaces: &workspaces,
+            path_index: &path_index,
             link_workspace_packages,
         };