[red-knot] Add support for untitled files (#12492)

## Summary

This PR adds support for untitled files in the Red Knot project.

Refer to the [design
discussion](https://github.com/astral-sh/ruff/discussions/12336) for
more details.

### Changes
* The `parsed_module` always assumes that the `SystemVirtual` path is of
`PySourceType::Python`.
* For the module resolver, as suggested, I went ahead by adding a new
`SystemOrVendoredPath` enum and renamed `FilePathRef` to
`SystemOrVendoredPathRef` (happy to consider better names here).
* The `file_to_module` query would return if it's a
`FilePath::SystemVirtual` variant because a virtual file doesn't belong
to any module.
* The sync implementation for the system virtual path is basically the
same as that of system path except that it uses the
`virtual_path_metadata`. The reason for this is that the system
(language server) would provide the metadata on whether it still exists
or not and if it exists, the corresponding metadata.

For point (1), VS Code would use `Untitled-1` for Python files and
`Untitled-1.ipynb` for Jupyter Notebooks. We could use this distinction
to determine whether the source type is `Python` or `Ipynb`.

## Test Plan

Added test cases in #12526

crates/ruff_db/src/files.rs

@@ -5,7 +5,7 @@ use dashmap::mapref::entry::Entry;
 
 use crate::file_revision::FileRevision;
 use crate::files::private::FileStatus;
-use crate::system::{SystemPath, SystemPathBuf};
+use crate::system::{Metadata, SystemPath, SystemPathBuf, SystemVirtualPath, SystemVirtualPathBuf};
 use crate::vendored::{VendoredPath, VendoredPathBuf};
 use crate::{Db, FxDashMap};
 pub use path::FilePath;
@@ -47,6 +47,9 @@ struct FilesInner {
     /// so that queries that depend on the existence of a file are re-executed when the file is created.
     system_by_path: FxDashMap<SystemPathBuf, File>,
 
+    /// Lookup table that maps [`SystemVirtualPathBuf`]s to salsa interned [`File`] instances.
+    system_virtual_by_path: FxDashMap<SystemVirtualPathBuf, File>,
+
     /// Lookup table that maps vendored files to the salsa [`File`] ingredients.
     vendored_by_path: FxDashMap<VendoredPathBuf, File>,
 }
@@ -126,6 +129,36 @@ impl Files {
         Some(file)
     }
 
+    /// Looks up a virtual file by its `path`.
+    ///
+    /// For a non-existing file, creates a new salsa [`File`] ingredient and stores it for future lookups.
+    ///
+    /// The operations fails if the system failed to provide a metadata for the path.
+    #[tracing::instrument(level = "trace", skip(self, db), ret)]
+    pub fn add_virtual_file(&self, db: &dyn Db, path: &SystemVirtualPath) -> Option<File> {
+        let file = match self.inner.system_virtual_by_path.entry(path.to_path_buf()) {
+            Entry::Occupied(entry) => *entry.get(),
+            Entry::Vacant(entry) => {
+                let metadata = db.system().virtual_path_metadata(path).ok()?;
+
+                let file = File::new(
+                    db,
+                    FilePath::SystemVirtual(path.to_path_buf()),
+                    metadata.permissions(),
+                    metadata.revision(),
+                    FileStatus::Exists,
+                    Count::default(),
+                );
+
+                entry.insert(file);
+
+                file
+            }
+        };
+
+        Some(file)
+    }
+
     /// Refreshes the state of all known files under `path` recursively.
     ///
     /// The most common use case is to update the [`Files`] state after removing or moving a directory.
@@ -227,6 +260,9 @@ impl File {
                 db.system().read_to_string(system)
             }
             FilePath::Vendored(vendored) => db.vendored().read_to_string(vendored),
+            FilePath::SystemVirtual(system_virtual) => {
+                db.system().read_virtual_path_to_string(system_virtual)
+            }
         }
     }
 
@@ -248,6 +284,9 @@ impl File {
                 std::io::ErrorKind::InvalidInput,
                 "Reading a notebook from the vendored file system is not supported.",
             ))),
+            FilePath::SystemVirtual(system_virtual) => {
+                db.system().read_virtual_path_to_notebook(system_virtual)
+            }
         }
     }
 
@@ -255,7 +294,7 @@ impl File {
     #[tracing::instrument(level = "debug", skip(db))]
     pub fn sync_path(db: &mut dyn Db, path: &SystemPath) {
         let absolute = SystemPath::absolute(path, db.system().current_directory());
-        Self::sync_impl(db, &absolute, None);
+        Self::sync_system_path(db, &absolute, None);
     }
 
     /// Syncs the [`File`]'s state with the state of the file on the system.
@@ -265,22 +304,33 @@ impl File {
 
         match path {
             FilePath::System(system) => {
-                Self::sync_impl(db, &system, Some(self));
+                Self::sync_system_path(db, &system, Some(self));
             }
             FilePath::Vendored(_) => {
                 // Readonly, can never be out of date.
             }
+            FilePath::SystemVirtual(system_virtual) => {
+                Self::sync_system_virtual_path(db, &system_virtual, self);
+            }
         }
     }
 
-    /// Private method providing the implementation for [`Self::sync_path`] and [`Self::sync_path`].
-    fn sync_impl(db: &mut dyn Db, path: &SystemPath, file: Option<File>) {
+    fn sync_system_path(db: &mut dyn Db, path: &SystemPath, file: Option<File>) {
         let Some(file) = file.or_else(|| db.files().try_system(db, path)) else {
             return;
         };
-
         let metadata = db.system().path_metadata(path);
+        Self::sync_impl(db, metadata, file);
+    }
 
+    fn sync_system_virtual_path(db: &mut dyn Db, path: &SystemVirtualPath, file: File) {
+        let metadata = db.system().virtual_path_metadata(path);
+        Self::sync_impl(db, metadata, file);
+    }
+
+    /// Private method providing the implementation for [`Self::sync_system_path`] and
+    /// [`Self::sync_system_virtual_path`].
+    fn sync_impl(db: &mut dyn Db, metadata: crate::system::Result<Metadata>, file: File) {
         let (status, revision, permission) = match metadata {
             Ok(metadata) if metadata.file_type().is_file() => (
                 FileStatus::Exists,