Factor tool definitions out of assistant (#21189)

This PR factors the tool definitions out of the `assistant` crate so
that they can be shared between `assistant` and `assistant2`.

`ToolWorkingSet` now lives in `assistant_tool`. The tool definitions
themselves live in `assistant_tools`, with the exception of the
`ContextServerTool`, which has been moved to the `context_server` crate.

As part of this refactoring I needed to extract the
`ContextServerSettings` to a separate `context_server_settings` crate so
that the `extension_host`—which is referenced by the `remote_server`—can
name the `ContextServerSettings` type without pulling in some undesired
dependencies.

Release Notes:

- N/A

crates/context_server/src/registry.rs

@@ -0,0 +1,62 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use collections::HashMap;
+use gpui::{AppContext, AsyncAppContext, Context, Global, Model, ReadGlobal, Task};
+use project::Project;
+
+use crate::ServerCommand;
+
+pub type ContextServerFactory = Arc<
+    dyn Fn(Model<Project>, &AsyncAppContext) -> Task<Result<ServerCommand>> + Send + Sync + 'static,
+>;
+
+struct GlobalContextServerFactoryRegistry(Model<ContextServerFactoryRegistry>);
+
+impl Global for GlobalContextServerFactoryRegistry {}
+
+#[derive(Default)]
+pub struct ContextServerFactoryRegistry {
+    context_servers: HashMap<Arc<str>, ContextServerFactory>,
+}
+
+impl ContextServerFactoryRegistry {
+    /// Returns the global [`ContextServerFactoryRegistry`].
+    pub fn global(cx: &AppContext) -> Model<Self> {
+        GlobalContextServerFactoryRegistry::global(cx).0.clone()
+    }
+
+    /// Returns the global [`ContextServerFactoryRegistry`].
+    ///
+    /// Inserts a default [`ContextServerFactoryRegistry`] if one does not yet exist.
+    pub fn default_global(cx: &mut AppContext) -> Model<Self> {
+        if !cx.has_global::<GlobalContextServerFactoryRegistry>() {
+            let registry = cx.new_model(|_| Self::new());
+            cx.set_global(GlobalContextServerFactoryRegistry(registry));
+        }
+        cx.global::<GlobalContextServerFactoryRegistry>().0.clone()
+    }
+
+    pub fn new() -> Self {
+        Self {
+            context_servers: HashMap::default(),
+        }
+    }
+
+    pub fn context_server_factories(&self) -> Vec<(Arc<str>, ContextServerFactory)> {
+        self.context_servers
+            .iter()
+            .map(|(id, factory)| (id.clone(), factory.clone()))
+            .collect()
+    }
+
+    /// Registers the provided [`ContextServerFactory`].
+    pub fn register_server_factory(&mut self, id: Arc<str>, factory: ContextServerFactory) {
+        self.context_servers.insert(id, factory);
+    }
+
+    /// Unregisters the [`ContextServerFactory`] for the server with the given ID.
+    pub fn unregister_server_factory_by_id(&mut self, server_id: &str) {
+        self.context_servers.remove(server_id);
+    }
+}