[ty] Support LSP client settings (#19614)

## Summary

This PR implements support for providing LSP client settings.

The complementary PR in the ty VS Code extension:
astral-sh/ty-vscode#106.

Notes for the previous iteration of this PR is in
https://github.com/astral-sh/ruff/pull/19614#issuecomment-3136477864
(click on "Details").

Specifically, this PR splits the client settings into 3 distinct groups.
Keep in mind that these groups are not visible to the user, they're
merely an implementation detail. The groups are:
1. `GlobalOptions` - these are the options that are global to the
language server and will be the same for all the workspaces that are
handled by the server
2. `WorkspaceOptions` - these are the options that are specific to a
workspace and will be applied only when running any logic for that
workspace
3. `InitializationOptions` - these are the options that can be specified
during initialization

The initialization options are a superset that contains both the global
and workspace options flattened into a 1-dimensional structure. This
means that the user can specify any and all fields present in
`GlobalOptions` and `WorkspaceOptions` in the initialization options in
addition to the fields that are _specific_ to initialization options.

From the current set of available settings, following are only available
during initialization because they are required at that time, are static
during the runtime of the server and changing their values require a
restart to take effect:
- `logLevel`
- `logFile`

And, following are available under `GlobalOptions`:
- `diagnosticMode`

And, following under `WorkspaceOptions`:
- `disableLanguageServices`
- `pythonExtension` (Python environment information that is populated by
the ty VS Code extension)

### `workspace/configuration`

This request allows server to ask the client for configuration to a
specific workspace. But, this is only supported by the client that has
the `workspace.configuration` client capability set to `true`. What to
do for clients that don't support pulling configurations?

In that case, the settings needs to be provided in the initialization
options and updating the values of those settings can only be done by
restarting the server. With the way this is implemented, this means that
if the client does not support pulling workspace configuration then
there's no way to specify settings specific to a workspace. Earlier,
this would've been possible by providing an array of client options with
an additional field which specifies which workspace the options belong
to but that adds complexity and clients that actually do not support
`workspace/configuration` would usually not support multiple workspaces
either.

Now, for the clients that do support this, the server will initiate the
request to get the configuration for all the workspaces at the start of
the server. Once the server receives these options, it will resolve them
for each workspace as follows:
1. Combine the client options sent during initialization with the
options specific to the workspace creating the final client options
that's specific to this workspace
2. Create a global options by combining the global options from (1) for
all workspaces which in turn will also combine the global options sent
during initialization

The global options are resolved into the global settings and are
available on the `Session` which is initialized with the default global
settings. The workspace options are resolved into the workspace settings
and are available on the respective `Workspace`.

The `SessionSnapshot` contains the global settings while the document
snapshot contains the workspace settings. We could add the global
settings to the document snapshot but that's currently not needed.

### Document diagnostic dynamic registration

Currently, the document diagnostic server capability is created based on
the `diagnosticMode` sent during initialization. But, that wouldn't
provide us with the complete picture. This means the server needs to
defer registering the document diagnostic capability at a later point
once the settings have been resolved.

This is done using dynamic registration for clients that support it. For
clients that do not support dynamic registration for document diagnostic
capability, the server advertises itself as always supporting workspace
diagnostics and work done progress token.

This dynamic registration now allows us to change the server capability
for workspace diagnostics based on the resolved `diagnosticMode` value.
In the future, once `workspace/didChangeConfiguration` is supported, we
can avoid the server restart when users have changed any client
settings.

## Test Plan

Add integration tests and recorded videos on the user experience in
various editors:

### VS Code

For VS Code users, the settings experience is unchanged because the
extension defines it's own interface on how the user can specify the
server setting. This means everything is under the `ty.*` namespace as
usual.


https://github.com/user-attachments/assets/c2e5ba5c-7617-406e-a09d-e397ce9c3b93

### Zed

For Zed, the settings experience has changed. Users can specify settings
during initialization:

```json
{
  "lsp": {
    "ty": {
      "initialization_options": {
        "logLevel": "debug",
        "logFile": "~/.cache/ty.log",
        "diagnosticMode": "workspace",
        "disableLanguageServices": true
      }
    },
  }
}
```

Or, can specify the options under the `settings` key:

```json
{
  "lsp": {
    "ty": {
      "settings": {
        "ty": {
          "diagnosticMode": "openFilesOnly",
          "disableLanguageServices": true
        }
      },
      "initialization_options": {
        "logLevel": "debug",
        "logFile": "~/.cache/ty.log"
      }
    },
  }
}
```

The `logLevel` and `logFile` setting still needs to go under the
initialization options because they're required by the server during
initialization.

We can remove the nesting of the settings under the "ty" namespace by
updating the return type of
db9ea0cdfd/src/tychecker.rs (L45-L49)
to be wrapped inside `ty` directly so that users can avoid doing the
double nesting.

There's one issue here which is that if the `diagnosticMode` is
specified in both the initialization option and settings key, then the
resolution is a bit different - if either of them is set to be
`workspace`, then it wins which means that in the following
configuration, the diagnostic mode is `workspace`:

```json
{
  "lsp": {
    "ty": {
      "settings": {
        "ty": {
          "diagnosticMode": "openFilesOnly"
        }
      },
      "initialization_options": {
        "diagnosticMode": "workspace"
      }
    },
  }
}
```

This behavior is mainly a result of combining global options from
various workspace configuration results. Users should not be able to
provide global options in multiple workspaces but that restriction
cannot be done on the server side. The ty VS Code extension restricts
these global settings to only be set in the user settings and not in
workspace settings but we do not control extensions in other editors.


https://github.com/user-attachments/assets/8e2d6c09-18e6-49e5-ab78-6cf942fe1255

### Neovim

Same as in Zed.

### Other

Other editors that do not support `workspace/configuration`, the users
would need to provide the server settings during initialization.

crates/ty_server/src/capabilities.rs

@@ -0,0 +1,264 @@
+use lsp_types::{ClientCapabilities, DiagnosticOptions, MarkupKind, WorkDoneProgressOptions};
+
+bitflags::bitflags! {
+    /// Represents the resolved client capabilities for the language server.
+    ///
+    /// This tracks various capabilities that the client supports.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+    pub(crate) struct ResolvedClientCapabilities: u32 {
+        const WORKSPACE_DIAGNOSTIC_REFRESH = 1 << 0;
+        const INLAY_HINT_REFRESH = 1 << 1;
+        const PULL_DIAGNOSTICS = 1 << 2;
+        const TYPE_DEFINITION_LINK_SUPPORT = 1 << 3;
+        const DEFINITION_LINK_SUPPORT = 1 << 4;
+        const DECLARATION_LINK_SUPPORT = 1 << 5;
+        const PREFER_MARKDOWN_IN_HOVER = 1 << 6;
+        const MULTILINE_SEMANTIC_TOKENS = 1 << 7;
+        const SIGNATURE_LABEL_OFFSET_SUPPORT = 1 << 8;
+        const SIGNATURE_ACTIVE_PARAMETER_SUPPORT = 1 << 9;
+        const HIERARCHICAL_DOCUMENT_SYMBOL_SUPPORT = 1 << 10;
+        const WORK_DONE_PROGRESS = 1 << 11;
+        const FILE_WATCHER_SUPPORT = 1 << 12;
+        const DIAGNOSTIC_DYNAMIC_REGISTRATION = 1 << 13;
+        const WORKSPACE_CONFIGURATION = 1 << 14;
+    }
+}
+
+impl ResolvedClientCapabilities {
+    /// Returns `true` if the client supports workspace diagnostic refresh.
+    pub(crate) const fn supports_workspace_diagnostic_refresh(self) -> bool {
+        self.contains(Self::WORKSPACE_DIAGNOSTIC_REFRESH)
+    }
+
+    /// Returns `true` if the client supports workspace configuration.
+    pub(crate) const fn supports_workspace_configuration(self) -> bool {
+        self.contains(Self::WORKSPACE_CONFIGURATION)
+    }
+
+    /// Returns `true` if the client supports inlay hint refresh.
+    pub(crate) const fn supports_inlay_hint_refresh(self) -> bool {
+        self.contains(Self::INLAY_HINT_REFRESH)
+    }
+
+    /// Returns `true` if the client supports pull diagnostics.
+    pub(crate) const fn supports_pull_diagnostics(self) -> bool {
+        self.contains(Self::PULL_DIAGNOSTICS)
+    }
+
+    /// Returns `true` if the client supports definition links in goto type definition.
+    pub(crate) const fn supports_type_definition_link(self) -> bool {
+        self.contains(Self::TYPE_DEFINITION_LINK_SUPPORT)
+    }
+
+    /// Returns `true` if the client supports definition links in goto definition.
+    pub(crate) const fn supports_definition_link(self) -> bool {
+        self.contains(Self::DEFINITION_LINK_SUPPORT)
+    }
+
+    /// Returns `true` if the client supports definition links in goto declaration.
+    pub(crate) const fn supports_declaration_link(self) -> bool {
+        self.contains(Self::DECLARATION_LINK_SUPPORT)
+    }
+
+    /// Returns `true` if the client prefers markdown in hover responses.
+    pub(crate) const fn prefers_markdown_in_hover(self) -> bool {
+        self.contains(Self::PREFER_MARKDOWN_IN_HOVER)
+    }
+
+    /// Returns `true` if the client supports multiline semantic tokens.
+    pub(crate) const fn supports_multiline_semantic_tokens(self) -> bool {
+        self.contains(Self::MULTILINE_SEMANTIC_TOKENS)
+    }
+
+    /// Returns `true` if the client supports signature label offsets in signature help.
+    pub(crate) const fn supports_signature_label_offset(self) -> bool {
+        self.contains(Self::SIGNATURE_LABEL_OFFSET_SUPPORT)
+    }
+
+    /// Returns `true` if the client supports per-signature active parameter in signature help.
+    pub(crate) const fn supports_signature_active_parameter(self) -> bool {
+        self.contains(Self::SIGNATURE_ACTIVE_PARAMETER_SUPPORT)
+    }
+
+    /// Returns `true` if the client supports hierarchical document symbols.
+    pub(crate) const fn supports_hierarchical_document_symbols(self) -> bool {
+        self.contains(Self::HIERARCHICAL_DOCUMENT_SYMBOL_SUPPORT)
+    }
+
+    /// Returns `true` if the client supports work done progress.
+    pub(crate) const fn supports_work_done_progress(self) -> bool {
+        self.contains(Self::WORK_DONE_PROGRESS)
+    }
+
+    /// Returns `true` if the client supports file watcher capabilities.
+    pub(crate) const fn supports_file_watcher(self) -> bool {
+        self.contains(Self::FILE_WATCHER_SUPPORT)
+    }
+
+    /// Returns `true` if the client supports dynamic registration for diagnostic capabilities.
+    pub(crate) const fn supports_diagnostic_dynamic_registration(self) -> bool {
+        self.contains(Self::DIAGNOSTIC_DYNAMIC_REGISTRATION)
+    }
+
+    pub(super) fn new(client_capabilities: &ClientCapabilities) -> Self {
+        let mut flags = Self::empty();
+
+        let workspace = client_capabilities.workspace.as_ref();
+        let text_document = client_capabilities.text_document.as_ref();
+
+        if workspace
+            .and_then(|workspace| workspace.diagnostics.as_ref()?.refresh_support)
+            .unwrap_or_default()
+        {
+            flags |= Self::WORKSPACE_DIAGNOSTIC_REFRESH;
+        }
+
+        if workspace
+            .and_then(|workspace| workspace.configuration)
+            .unwrap_or_default()
+        {
+            flags |= Self::WORKSPACE_CONFIGURATION;
+        }
+
+        if workspace
+            .and_then(|workspace| workspace.inlay_hint.as_ref()?.refresh_support)
+            .unwrap_or_default()
+        {
+            flags |= Self::INLAY_HINT_REFRESH;
+        }
+
+        if workspace
+            .and_then(|workspace| workspace.did_change_watched_files?.dynamic_registration)
+            .unwrap_or_default()
+        {
+            flags |= Self::FILE_WATCHER_SUPPORT;
+        }
+
+        if text_document.is_some_and(|text_document| text_document.diagnostic.is_some()) {
+            flags |= Self::PULL_DIAGNOSTICS;
+        }
+
+        if text_document
+            .and_then(|text_document| text_document.diagnostic.as_ref()?.dynamic_registration)
+            .unwrap_or_default()
+        {
+            flags |= Self::DIAGNOSTIC_DYNAMIC_REGISTRATION;
+        }
+
+        if text_document
+            .and_then(|text_document| text_document.type_definition?.link_support)
+            .unwrap_or_default()
+        {
+            flags |= Self::TYPE_DEFINITION_LINK_SUPPORT;
+        }
+
+        if text_document
+            .and_then(|text_document| text_document.definition?.link_support)
+            .unwrap_or_default()
+        {
+            flags |= Self::DEFINITION_LINK_SUPPORT;
+        }
+
+        if text_document
+            .and_then(|text_document| text_document.declaration?.link_support)
+            .unwrap_or_default()
+        {
+            flags |= Self::DECLARATION_LINK_SUPPORT;
+        }
+
+        if text_document
+            .and_then(|text_document| {
+                Some(
+                    text_document
+                        .hover
+                        .as_ref()?
+                        .content_format
+                        .as_ref()?
+                        .contains(&MarkupKind::Markdown),
+                )
+            })
+            .unwrap_or_default()
+        {
+            flags |= Self::PREFER_MARKDOWN_IN_HOVER;
+        }
+
+        if text_document
+            .and_then(|text_document| {
+                text_document
+                    .semantic_tokens
+                    .as_ref()?
+                    .multiline_token_support
+            })
+            .unwrap_or_default()
+        {
+            flags |= Self::MULTILINE_SEMANTIC_TOKENS;
+        }
+
+        if text_document
+            .and_then(|text_document| {
+                text_document
+                    .signature_help
+                    .as_ref()?
+                    .signature_information
+                    .as_ref()?
+                    .parameter_information
+                    .as_ref()?
+                    .label_offset_support
+            })
+            .unwrap_or_default()
+        {
+            flags |= Self::SIGNATURE_LABEL_OFFSET_SUPPORT;
+        }
+
+        if text_document
+            .and_then(|text_document| {
+                text_document
+                    .signature_help
+                    .as_ref()?
+                    .signature_information
+                    .as_ref()?
+                    .active_parameter_support
+            })
+            .unwrap_or_default()
+        {
+            flags |= Self::SIGNATURE_ACTIVE_PARAMETER_SUPPORT;
+        }
+
+        if text_document
+            .and_then(|text_document| {
+                text_document
+                    .document_symbol
+                    .as_ref()?
+                    .hierarchical_document_symbol_support
+            })
+            .unwrap_or_default()
+        {
+            flags |= Self::HIERARCHICAL_DOCUMENT_SYMBOL_SUPPORT;
+        }
+
+        if client_capabilities
+            .window
+            .as_ref()
+            .and_then(|window| window.work_done_progress)
+            .unwrap_or_default()
+        {
+            flags |= Self::WORK_DONE_PROGRESS;
+        }
+
+        flags
+    }
+}
+
+/// Creates the default [`DiagnosticOptions`] for the server.
+pub(crate) fn server_diagnostic_options(workspace_diagnostics: bool) -> DiagnosticOptions {
+    DiagnosticOptions {
+        identifier: Some(crate::DIAGNOSTIC_NAME.to_string()),
+        inter_file_dependencies: true,
+        workspace_diagnostics,
+        work_done_progress_options: WorkDoneProgressOptions {
+            // Currently, the server only supports reporting work done progress for "workspace"
+            // diagnostic mode.
+            work_done_progress: Some(workspace_diagnostics),
+        },
+    }
+}