Avoid parsing with Salsa (#13437)

## Summary

For reasons I haven't investigated, this speeds up the resolver about 2x
(from 6.404s to 3.612s on an extremely large codebase).

## Test Plan

\cc @BurntSushi 

```
[andrew@duff rippling]$ time ruff analyze graph --preview > /dev/null

real    3.274
user    16.039
sys     7.609
maxmem  11631 MB
faults  0
[andrew@duff rippling]$ time ruff-patch analyze graph --preview > /dev/null

real    1.841
user    14.625
sys     3.639
maxmem  7173 MB
faults  0
[andrew@duff rippling]$ time ruff-patch2 analyze graph --preview > /dev/null

real    2.087
user    15.333
sys     4.869
maxmem  8642 MB
faults  0
```

Where that's `main`, then (`ruff-patch`) using the version with no
`File`, no `SemanticModel`, then (`ruff-patch2`) using `File`.

crates/ruff_graph/src/resolver.rs

@@ -1,37 +1,36 @@
-use red_knot_python_semantic::SemanticModel;
+use red_knot_python_semantic::resolve_module;
 use ruff_db::files::FilePath;
 
 use crate::collector::CollectedImport;
+use crate::ModuleDb;
 
 /// Collect all imports for a given Python file.
 pub(crate) struct Resolver<'a> {
-    semantic: &'a SemanticModel<'a>,
+    db: &'a ModuleDb,
 }
 
 impl<'a> Resolver<'a> {
-    /// Initialize a [`Resolver`] with a given [`SemanticModel`].
-    pub(crate) fn new(semantic: &'a SemanticModel<'a>) -> Self {
-        Self { semantic }
+    /// Initialize a [`Resolver`] with a given [`ModuleDb`].
+    pub(crate) fn new(db: &'a ModuleDb) -> Self {
+        Self { db }
     }
 
     /// Resolve the [`CollectedImport`] into a [`FilePath`].
     pub(crate) fn resolve(&self, import: CollectedImport) -> Option<&'a FilePath> {
         match import {
-            CollectedImport::Import(import) => self
-                .semantic
-                .resolve_module(import)
-                .map(|module| module.file().path(self.semantic.db())),
+            CollectedImport::Import(import) => {
+                resolve_module(self.db, import).map(|module| module.file().path(self.db))
+            }
             CollectedImport::ImportFrom(import) => {
                 // Attempt to resolve the member (e.g., given `from foo import bar`, look for `foo.bar`).
                 let parent = import.parent();
-                self.semantic
-                    .resolve_module(import)
-                    .map(|module| module.file().path(self.semantic.db()))
+
+                resolve_module(self.db, import)
+                    .map(|module| module.file().path(self.db))
                     .or_else(|| {
                         // Attempt to resolve the module (e.g., given `from foo import bar`, look for `foo`).
-                        self.semantic
-                            .resolve_module(parent?)
-                            .map(|module| module.file().path(self.semantic.db()))
+
+                        resolve_module(self.db, parent?).map(|module| module.file().path(self.db))
                     })
             }
         }