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/db.rs

@@ -0,0 +1,94 @@
+use anyhow::Result;
+use red_knot_python_semantic::{Db, Program, ProgramSettings, PythonVersion, SearchPathSettings};
+use ruff_db::files::{File, Files};
+use ruff_db::system::{OsSystem, System, SystemPathBuf};
+use ruff_db::vendored::VendoredFileSystem;
+use ruff_db::{Db as SourceDb, Upcast};
+
+#[salsa::db]
+#[derive(Default)]
+pub struct ModuleDb {
+    storage: salsa::Storage<Self>,
+    files: Files,
+    system: OsSystem,
+    vendored: VendoredFileSystem,
+}
+
+impl ModuleDb {
+    /// Initialize a [`ModuleDb`] from the given source root.
+    pub fn from_src_roots(mut src_roots: impl Iterator<Item = SystemPathBuf>) -> Result<Self> {
+        let search_paths = {
+            // Use the first source root.
+            let src_root = src_roots
+                .next()
+                .ok_or_else(|| anyhow::anyhow!("No source roots provided"))?;
+
+            let mut search_paths = SearchPathSettings::new(src_root.to_path_buf());
+
+            // Add the remaining source roots as extra paths.
+            for src_root in src_roots {
+                search_paths.extra_paths.push(src_root.to_path_buf());
+            }
+
+            search_paths
+        };
+
+        let db = Self::default();
+        Program::from_settings(
+            &db,
+            &ProgramSettings {
+                target_version: PythonVersion::default(),
+                search_paths,
+            },
+        )?;
+
+        Ok(db)
+    }
+
+    /// Create a snapshot of the current database.
+    #[must_use]
+    pub fn snapshot(&self) -> Self {
+        Self {
+            storage: self.storage.clone(),
+            system: self.system.clone(),
+            vendored: self.vendored.clone(),
+            files: self.files.snapshot(),
+        }
+    }
+}
+
+impl Upcast<dyn SourceDb> for ModuleDb {
+    fn upcast(&self) -> &(dyn SourceDb + 'static) {
+        self
+    }
+    fn upcast_mut(&mut self) -> &mut (dyn SourceDb + 'static) {
+        self
+    }
+}
+
+#[salsa::db]
+impl SourceDb for ModuleDb {
+    fn vendored(&self) -> &VendoredFileSystem {
+        &self.vendored
+    }
+
+    fn system(&self) -> &dyn System {
+        &self.system
+    }
+
+    fn files(&self) -> &Files {
+        &self.files
+    }
+}
+
+#[salsa::db]
+impl Db for ModuleDb {
+    fn is_file_open(&self, file: File) -> bool {
+        !file.path(self).is_vendored_path()
+    }
+}
+
+#[salsa::db]
+impl salsa::Database for ModuleDb {
+    fn salsa_event(&self, _event: &dyn Fn() -> salsa::Event) {}
+}