Add a subcommand to generate dependency graphs (#13402)

## Summary

This PR adds an experimental Ruff subcommand to generate dependency
graphs based on module resolution.

A few highlights:

- You can generate either dependency or dependent graphs via the
`--direction` command-line argument.
- Like Pants, we also provide an option to identify imports from string
literals (`--detect-string-imports`).
- Users can also provide additional dependency data via the
`include-dependencies` key under `[tool.ruff.import-map]`. This map uses
file paths as keys, and lists of strings as values. Those strings can be
file paths or globs.

The dependency resolution uses the red-knot module resolver which is
intended to be fully spec compliant, so it's also a chance to expose the
module resolver in a real-world setting.

The CLI is, e.g., `ruff graph build ../autobot`, which will output a
JSON map from file to files it depends on for the `autobot` project.

crates/ruff_graph/src/settings.rs

@@ -0,0 +1,52 @@
+use ruff_linter::display_settings;
+use ruff_linter::settings::types::{ExtensionMapping, PreviewMode};
+use ruff_macros::CacheKey;
+use std::collections::BTreeMap;
+use std::fmt;
+use std::path::PathBuf;
+
+#[derive(Debug, Default, Clone, CacheKey)]
+pub struct AnalyzeSettings {
+    pub preview: PreviewMode,
+    pub detect_string_imports: bool,
+    pub include_dependencies: BTreeMap<PathBuf, (PathBuf, Vec<String>)>,
+    pub extension: ExtensionMapping,
+}
+
+impl fmt::Display for AnalyzeSettings {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "\n# Analyze Settings")?;
+        display_settings! {
+            formatter = f,
+            namespace = "analyze",
+            fields = [
+                self.preview,
+                self.detect_string_imports,
+                self.extension | debug,
+                self.include_dependencies | debug,
+            ]
+        }
+        Ok(())
+    }
+}
+
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, CacheKey)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
+pub enum Direction {
+    /// Construct a map from module to its dependencies (i.e., the modules that it imports).
+    #[default]
+    Dependencies,
+    /// Construct a map from module to its dependents (i.e., the modules that import it).
+    Dependents,
+}
+
+impl fmt::Display for Direction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Dependencies => write!(f, "\"dependencies\""),
+            Self::Dependents => write!(f, "\"dependents\""),
+        }
+    }
+}