Use Arc<[PathBuf]> to reduce cloning overhead for shared path lists (#299)

Path lists are frequently cloned when passed to threads during
environment discovery. Since these paths are immutable once created,
`Arc<[PathBuf]>` provides O(1) cloning via atomic increment instead of
O(n) deep copies.

### Changes

- **Convert shared path lists to `Arc<[PathBuf]>`**
  - `environment_directories` converted before thread spawns
  - `global_env_search_paths` converted in workspace directory loop

- **Update function signatures to accept `&[PathBuf]`**
  - `find_python_environments`
  - `find_python_environments_in_paths_with_locators`

- **Remove unnecessary clones**
  - Pass references where ownership isn't needed
  - `find_executables` accepts `AsRef<Path>`, no clone required

### Before/After

```rust
// Before: O(n) clone per workspace folder
for workspace_folder in workspace_directories {
    let global_env_search_paths = global_env_search_paths.clone(); // deep copy
    // ...
}

// After: O(1) clone per workspace folder
let global_env_search_paths: Arc<[PathBuf]> = 
    get_search_paths_from_env_variables(environment).into();
for workspace_folder in workspace_directories {
    let global_env_search_paths = global_env_search_paths.clone(); // atomic increment
    // ...
}
```

<!-- START COPILOT ORIGINAL PROMPT -->



<details>

<summary>Original prompt</summary>

> 
> ----
> 
> *This section details on the original issue you should resolve*
> 
> <issue_title>Performance: Use Arc<[PathBuf]> to reduce cloning
overhead for shared path lists</issue_title>
> <issue_description>## Summary
> The codebase frequently clones `Vec<PathBuf>` when passing path lists
to threads. Since these paths are typically immutable once created,
wrapping them in `Arc<[PathBuf]>` would eliminate deep cloning overhead.
> 
> ## Affected Locations
> 
> ### `crates/pet/src/find.rs`
> ```rust
> // Line 128: Clones entire vector for each iteration
> global_env_search_paths.clone(),
> 
> // Line 142: Clone before thread scope
> let environment_directories_search = environment_directories.clone();
> 
> // Lines 212-213: Clones inside thread spawn
> let global_env_search_paths = global_env_search_paths.clone();
> let environment_directories = environment_directories.clone();
> ```
> 
> ### `crates/pet-conda/src/lib.rs`
> ```rust
> // Line 94: Clones entire HashMap to iterate
> let environments = self.environments.lock().unwrap().clone();
> ```
> 
> ## Proposed Solution
> 
> ### Option 1: Use `Arc<[PathBuf]>`
> ```rust
> // Instead of:
> let global_env_search_paths: Vec<PathBuf> =
get_search_paths_from_env_variables(environment);
> 
> // Use:
> let global_env_search_paths: Arc<[PathBuf]> = 
>     get_search_paths_from_env_variables(environment).into();
> 
> // Then cloning is cheap (just atomic increment):
> let paths = global_env_search_paths.clone(); // O(1) instead of O(n)
> ```
> 
> ### Option 2: Pass references where possible
> For `thread::scope` contexts, references can often be passed directly:
> ```rust
> thread::scope(|s| {
>     let paths = &global_env_search_paths; // borrow instead of clone
>     s.spawn(move || {
>         // use paths
>     });
> });
> ```
> 
> ## Impact
> - Reduces memory allocations during environment discovery
> - Particularly impactful when there are many workspace directories or
PATH entries
> - `Arc<[PathBuf]>` has same memory layout as `Vec<PathBuf>` but with
shared ownership
> 
> ## Priority
> Medium - Reduces allocations but requires API changes to helper
functions.</issue_description>
> 
> <agent_instructions>Fix the issue. See if the recommendation makes
sense and create a fix.</agent_instructions>
> 
> ## Comments on the Issue (you are @copilot in this section)
> 
> <comments>
> </comments>
> 


</details>



<!-- START COPILOT CODING AGENT SUFFIX -->

- Fixes #287

<!-- START COPILOT CODING AGENT TIPS -->
---

💬 We'd love your input! Share your thoughts on Copilot coding agent in
our [2 minute survey](https://gh.io/copilot-coding-agent-survey).

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: karthiknadig <[email protected]>

Author: Copilot

crates/pet/src/find.rs

@@ -125,7 +125,7 @@ pub fn find_and_report_envs(
                     global_env_search_paths
                 );
                 find_python_environments(
-                    global_env_search_paths.clone(),
+                    &global_env_search_paths,
                     reporter,
                     locators,
                     false,
@@ -139,14 +139,17 @@ pub fn find_and_report_envs(
                 .insert("Path", start.elapsed());
         });
         // Step 3: Search in some global locations for virtual envs.
-        let environment_directories_search = environment_directories.clone();
-        s.spawn(|| {
+        // Convert to Arc<[PathBuf]> for O(1) cloning in thread spawns
+        let environment_directories: Arc<[PathBuf]> = environment_directories.into();
+        let environment_directories_for_step3 = environment_directories.clone();
+        let summary_for_step3 = summary.clone();
+        s.spawn(move || {
             let start = std::time::Instant::now();
             if search_global {
                 let mut possible_environments = vec![];
 
                 // These are directories that contain environments, hence enumerate these directories.
-                for directory in environment_directories_search {
+                for directory in environment_directories_for_step3.iter() {
                     if let Ok(reader) = fs::read_dir(directory) {
                         possible_environments.append(
                             &mut reader
@@ -177,14 +180,14 @@ pub fn find_and_report_envs(
                 );
 
                 find_python_environments(
-                    search_paths,
+                    &search_paths,
                     reporter,
                     locators,
                     false,
                     &global_env_search_paths,
                 );
             }
-            summary
+            summary_for_step3
                 .lock()
                 .unwrap()
                 .breakdown
@@ -197,7 +200,8 @@ pub fn find_and_report_envs(
         // This list of folders generally map to workspace folders
         // & users can have a lot of workspace folders and can have a large number fo files/directories
         // that could the discovery.
-        s.spawn(|| {
+        let summary_for_step4 = summary.clone();
+        s.spawn(move || {
             let start = std::time::Instant::now();
             thread::scope(|s| {
                 // Find environments in the workspace folders.
@@ -206,8 +210,9 @@ pub fn find_and_report_envs(
                         "Searching for environments in workspace folders: {:?}",
                         workspace_directories
                     );
-                    let global_env_search_paths: Vec<PathBuf> =
-                        get_search_paths_from_env_variables(environment);
+                    // Convert to Arc<[PathBuf]> for O(1) cloning in thread spawns
+                    let global_env_search_paths: Arc<[PathBuf]> =
+                        get_search_paths_from_env_variables(environment).into();
                     for workspace_folder in workspace_directories {
                         let global_env_search_paths = global_env_search_paths.clone();
                         let environment_directories = environment_directories.clone();
@@ -236,7 +241,7 @@ pub fn find_and_report_envs(
                 }
             });
 
-            summary
+            summary_for_step4
                 .lock()
                 .unwrap()
                 .breakdown
@@ -277,7 +282,7 @@ pub fn find_python_environments_in_workspace_folder_recursive(
 
     // Possible this is an environment.
     find_python_environments_in_paths_with_locators(
-        paths_to_search_first.clone(),
+        &paths_to_search_first,
         locators,
         reporter,
         true,
@@ -309,13 +314,13 @@ pub fn find_python_environments_in_workspace_folder_recursive(
             })
             .filter(|p| !paths_to_search_first.contains(p))
         {
-            find_python_environments(vec![folder], reporter, locators, true, &[]);
+            find_python_environments(&[folder], reporter, locators, true, &[]);
         }
     }
 }
 
 fn find_python_environments(
-    paths: Vec<PathBuf>,
+    paths: &[PathBuf],
     reporter: &dyn Reporter,
     locators: &Arc<Vec<Arc<dyn Locator>>>,
     is_workspace_folder: bool,
@@ -327,9 +332,10 @@ fn find_python_environments(
     thread::scope(|s| {
         for item in paths {
             let locators = locators.clone();
+            let item = item.clone();
             s.spawn(move || {
                 find_python_environments_in_paths_with_locators(
-                    vec![item],
+                    &[item],
                     &locators,
                     reporter,
                     is_workspace_folder,
@@ -341,7 +347,7 @@ fn find_python_environments(
 }
 
 fn find_python_environments_in_paths_with_locators(
-    paths: Vec<PathBuf>,
+    paths: &[PathBuf],
     locators: &Arc<Vec<Arc<dyn Locator>>>,
     reporter: &dyn Reporter,
     is_workspace_folder: bool,
@@ -356,7 +362,7 @@ fn find_python_environments_in_paths_with_locators(
 
             // Paths like /Library/Frameworks/Python.framework/Versions/3.10/bin can end up in the current PATH variable.
             // Hence do not just look for files in a bin directory of the path.
-            if let Some(executable) = find_executable(&path) {
+            if let Some(executable) = find_executable(path) {
                 vec![executable]
             } else {
                 vec![]