windows: Fix fs watch when file doesn't exist or is a symlink (#22660)

Closes #22659

More context can be found in attached issue.

This is specific to Windows:

1. Add parent directory watching for fs watch when the file doesn't
exist. For example, when Zed is first launched and `settings.json` isn't
there.
2. Add proper symlink handling for fs watch. For example, when
`settings.json` is a symlink.

This is exactly same as how we handle it on Linux.

Release Notes:

- Fixed an issue where items on the Welcome page could not be toggled on
Windows, either on first launch or when `settings.json` is a symlink.

crates/fs/src/fs_watcher.rs

@@ -0,0 +1,127 @@
+use notify::EventKind;
+use parking_lot::Mutex;
+use std::sync::{Arc, OnceLock};
+use util::ResultExt;
+
+use crate::{PathEvent, PathEventKind, Watcher};
+
+pub struct FsWatcher {
+    tx: smol::channel::Sender<()>,
+    pending_path_events: Arc<Mutex<Vec<PathEvent>>>,
+}
+
+impl FsWatcher {
+    pub fn new(
+        tx: smol::channel::Sender<()>,
+        pending_path_events: Arc<Mutex<Vec<PathEvent>>>,
+    ) -> Self {
+        Self {
+            tx,
+            pending_path_events,
+        }
+    }
+}
+
+impl Watcher for FsWatcher {
+    fn add(&self, path: &std::path::Path) -> gpui::Result<()> {
+        let root_path = path.to_path_buf();
+
+        let tx = self.tx.clone();
+        let pending_paths = self.pending_path_events.clone();
+
+        use notify::Watcher;
+
+        global({
+            |g| {
+                g.add(move |event: &notify::Event| {
+                    let kind = match event.kind {
+                        EventKind::Create(_) => Some(PathEventKind::Created),
+                        EventKind::Modify(_) => Some(PathEventKind::Changed),
+                        EventKind::Remove(_) => Some(PathEventKind::Removed),
+                        _ => None,
+                    };
+                    let mut path_events = event
+                        .paths
+                        .iter()
+                        .filter_map(|event_path| {
+                            event_path.starts_with(&root_path).then(|| PathEvent {
+                                path: event_path.clone(),
+                                kind,
+                            })
+                        })
+                        .collect::<Vec<_>>();
+
+                    if !path_events.is_empty() {
+                        path_events.sort();
+                        let mut pending_paths = pending_paths.lock();
+                        if pending_paths.is_empty() {
+                            tx.try_send(()).ok();
+                        }
+                        util::extend_sorted(
+                            &mut *pending_paths,
+                            path_events,
+                            usize::MAX,
+                            |a, b| a.path.cmp(&b.path),
+                        );
+                    }
+                })
+            }
+        })?;
+
+        global(|g| {
+            g.watcher
+                .lock()
+                .watch(path, notify::RecursiveMode::NonRecursive)
+        })??;
+
+        Ok(())
+    }
+
+    fn remove(&self, path: &std::path::Path) -> gpui::Result<()> {
+        use notify::Watcher;
+        Ok(global(|w| w.watcher.lock().unwatch(path))??)
+    }
+}
+
+pub struct GlobalWatcher {
+    // two mutexes because calling watcher.add triggers an watcher.event, which needs watchers.
+    #[cfg(target_os = "linux")]
+    pub(super) watcher: Mutex<notify::INotifyWatcher>,
+    #[cfg(target_os = "freebsd")]
+    pub(super) watcher: Mutex<notify::KqueueWatcher>,
+    #[cfg(target_os = "windows")]
+    pub(super) watcher: Mutex<notify::ReadDirectoryChangesWatcher>,
+    pub(super) watchers: Mutex<Vec<Box<dyn Fn(&notify::Event) + Send + Sync>>>,
+}
+
+impl GlobalWatcher {
+    pub(super) fn add(&self, cb: impl Fn(&notify::Event) + Send + Sync + 'static) {
+        self.watchers.lock().push(Box::new(cb))
+    }
+}
+
+static FS_WATCHER_INSTANCE: OnceLock<anyhow::Result<GlobalWatcher, notify::Error>> =
+    OnceLock::new();
+
+fn handle_event(event: Result<notify::Event, notify::Error>) {
+    let Some(event) = event.log_err() else { return };
+    global::<()>(move |watcher| {
+        for f in watcher.watchers.lock().iter() {
+            f(&event)
+        }
+    })
+    .log_err();
+}
+
+pub fn global<T>(f: impl FnOnce(&GlobalWatcher) -> T) -> anyhow::Result<T> {
+    let result = FS_WATCHER_INSTANCE.get_or_init(|| {
+        notify::recommended_watcher(handle_event).map(|file_watcher| GlobalWatcher {
+            watcher: Mutex::new(file_watcher),
+            watchers: Default::default(),
+        })
+    });
+    match result {
+        Ok(g) => Ok(f(g)),
+        Err(e) => Err(anyhow::anyhow!("{}", e)),
+    }
+}