Support tasks from rust-analyzer (#28359)

(and any other LSP server in theory, if it exposes any LSP-ext endpoint
for the same)

Closes https://github.com/zed-industries/zed/issues/16160

* adds a way to disable tree-sitter tasks (the ones from the plugins,
enabled by default) with
```json5
"languages": {
  "Rust": "tasks": {
      "enabled": false
    }
  }
}
```
language settings

* adds a way to disable LSP tasks (the ones from the rust-analyzer
language server, enabled by default) with
```json5
"lsp": {
  "rust-analyzer": {
    "enable_lsp_tasks": false,
  }
}
```

* adds rust-analyzer tasks into tasks modal and gutter:

<img width="1728" alt="modal"
src="https://github.com/user-attachments/assets/22b9cee1-4ffb-4c9e-b1f1-d01e80e72508"
/>

<img width="396" alt="gutter"
src="https://github.com/user-attachments/assets/bd818079-e247-4332-bdb5-1b7cb1cce768"
/>


Release Notes:

- Added tasks from rust-analyzer

crates/editor/src/lsp_ext.rs

@@ -1,12 +1,25 @@
 use std::sync::Arc;
 
 use crate::Editor;
+use collections::HashMap;
+use futures::stream::FuturesUnordered;
 use gpui::{App, AppContext as _, Entity, Task};
 use itertools::Itertools;
 use language::Buffer;
 use language::Language;
 use lsp::LanguageServerId;
+use lsp::LanguageServerName;
 use multi_buffer::Anchor;
+use project::LanguageServerToQuery;
+use project::LocationLink;
+use project::Project;
+use project::TaskSourceKind;
+use project::lsp_store::lsp_ext_command::GetLspRunnables;
+use smol::stream::StreamExt;
+use task::ResolvedTask;
+use task::TaskContext;
+use text::BufferId;
+use util::ResultExt as _;
 
 pub(crate) fn find_specific_language_server_in_selection<F>(
     editor: &Editor,
@@ -60,3 +73,83 @@ where
         None
     })
 }
+
+pub fn lsp_tasks(
+    project: Entity<Project>,
+    task_sources: &HashMap<LanguageServerName, Vec<BufferId>>,
+    for_position: Option<text::Anchor>,
+    cx: &mut App,
+) -> Task<Vec<(TaskSourceKind, Vec<(Option<LocationLink>, ResolvedTask)>)>> {
+    let mut lsp_task_sources = task_sources
+        .iter()
+        .map(|(name, buffer_ids)| {
+            let buffers = buffer_ids
+                .iter()
+                .filter_map(|&buffer_id| project.read(cx).buffer_for_id(buffer_id, cx))
+                .collect::<Vec<_>>();
+            language_server_for_buffers(project.clone(), name.clone(), buffers, cx)
+        })
+        .collect::<FuturesUnordered<_>>();
+
+    cx.spawn(async move |cx| {
+        let mut lsp_tasks = Vec::new();
+        let lsp_task_context = TaskContext::default();
+        while let Some(server_to_query) = lsp_task_sources.next().await {
+            if let Some((server_id, buffers)) = server_to_query {
+                let source_kind = TaskSourceKind::Lsp(server_id);
+                let id_base = source_kind.to_id_base();
+                let mut new_lsp_tasks = Vec::new();
+                for buffer in buffers {
+                    if let Ok(runnables_task) = project.update(cx, |project, cx| {
+                        let buffer_id = buffer.read(cx).remote_id();
+                        project.request_lsp(
+                            buffer,
+                            LanguageServerToQuery::Other(server_id),
+                            GetLspRunnables {
+                                buffer_id,
+                                position: for_position,
+                            },
+                            cx,
+                        )
+                    }) {
+                        if let Some(new_runnables) = runnables_task.await.log_err() {
+                            new_lsp_tasks.extend(new_runnables.runnables.into_iter().filter_map(
+                                |(location, runnable)| {
+                                    let resolved_task =
+                                        runnable.resolve_task(&id_base, &lsp_task_context)?;
+                                    Some((location, resolved_task))
+                                },
+                            ));
+                        }
+                    }
+                }
+                lsp_tasks.push((source_kind, new_lsp_tasks));
+            }
+        }
+        lsp_tasks
+    })
+}
+
+fn language_server_for_buffers(
+    project: Entity<Project>,
+    name: LanguageServerName,
+    candidates: Vec<Entity<Buffer>>,
+    cx: &mut App,
+) -> Task<Option<(LanguageServerId, Vec<Entity<Buffer>>)>> {
+    cx.spawn(async move |cx| {
+        for buffer in &candidates {
+            let server_id = buffer
+                .update(cx, |buffer, cx| {
+                    project.update(cx, |project, cx| {
+                        project.language_server_id_for_name(buffer, &name.0, cx)
+                    })
+                })
+                .ok()?
+                .await;
+            if let Some(server_id) = server_id {
+                return Some((server_id, candidates));
+            }
+        }
+        None
+    })
+}