Refactor: Make it possible to share a remote worktree (#12775)

This PR is an internal refactor in preparation for remote editing. It
restructures the public interface of `Worktree`, reducing the number of
call sites that assume that a worktree is local or remote.

* The Project no longer calls `worktree.as_local_mut().unwrap()` in code
paths related to basic file operations
* Fewer code paths in the app rely on the worktree's `LocalSnapshot`
* Worktree-related RPC message handling is more fully encapsulated by
the `Worktree` type.

to do:
* [x] file manipulation operations
* [x] sending worktree updates when sharing

for later
* opening buffers
* updating open buffers upon worktree changes

Release Notes:

- N/A

crates/worktree/src/worktree_settings.rs

@@ -1,10 +1,37 @@
+use std::{path::Path, sync::Arc};
+
 use gpui::AppContext;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
+use util::paths::PathMatcher;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct WorktreeSettings {
+    pub file_scan_exclusions: Arc<[PathMatcher]>,
+    pub private_files: Arc<[PathMatcher]>,
+}
+
+impl WorktreeSettings {
+    pub fn is_path_private(&self, path: &Path) -> bool {
+        path.ancestors().any(|ancestor| {
+            self.private_files
+                .iter()
+                .any(|matcher| matcher.is_match(&ancestor))
+        })
+    }
+
+    pub fn is_path_excluded(&self, path: &Path) -> bool {
+        path.ancestors().any(|ancestor| {
+            self.file_scan_exclusions
+                .iter()
+                .any(|matcher| matcher.is_match(&ancestor))
+        })
+    }
+}
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct WorktreeSettings {
+pub struct WorktreeSettingsContent {
     /// Completely ignore files matching globs from `file_scan_exclusions`
     ///
     /// Default: [
@@ -28,12 +55,37 @@ pub struct WorktreeSettings {
 impl Settings for WorktreeSettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = Self;
+    type FileContent = WorktreeSettingsContent;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
         _: &mut AppContext,
     ) -> anyhow::Result<Self> {
-        sources.json_merge()
+        let result: WorktreeSettingsContent = sources.json_merge()?;
+        let mut file_scan_exclusions = result.file_scan_exclusions.unwrap_or_default();
+        let mut private_files = result.private_files.unwrap_or_default();
+        file_scan_exclusions.sort();
+        private_files.sort();
+        Ok(Self {
+            file_scan_exclusions: path_matchers(&file_scan_exclusions, "file_scan_exclusions"),
+            private_files: path_matchers(&private_files, "private_files"),
+        })
     }
 }
+
+fn path_matchers(values: &[String], context: &'static str) -> Arc<[PathMatcher]> {
+    values
+        .iter()
+        .filter_map(|pattern| {
+            PathMatcher::new(pattern)
+                .map(Some)
+                .unwrap_or_else(|e| {
+                    log::error!(
+                        "Skipping pattern {pattern} in `{}` project settings due to parsing error: {e:#}", context
+                    );
+                    None
+                })
+        })
+        .collect::<Vec<_>>()
+        .into()
+}