[ty] Disallow std::env and io methods in most ty crates (#20046)

## Summary

We use the `System` abstraction in ty to abstract away the host/system
on which ty runs.
This has a few benefits:

* Tests can run in full isolation using a memory system (that uses an
in-memory file system)
* The LSP has a custom implementation where `read_to_string` returns the
content as seen by the editor (e.g. unsaved changes) instead of always
returning the content as it is stored on disk
* We don't require any file system polyfills for wasm in the browser


However, it does require extra care that we don't accidentally use
`std::fs` or `std::env` (etc.) methods in ty's code base (which is very
easy).

This PR sets up Clippy and disallows the most common methods, instead
pointing users towards the corresponding `System` methods.

The setup is a bit awkward because clippy doesn't support inheriting
configurations. That means, a crate can only override the entire
workspace configuration or not at all.
The approach taken in this PR is:

* Configure the disallowed methods at the workspace level
* Allow `disallowed_methods` at the workspace level
* Enable the lint at the crate level using the warn attribute (in code)


The obvious downside is that it won't work if we ever want to disallow
other methods, but we can figure that out once we reach that point.

What about false positives: Just add an `allow` and move on with your
life :) This isn't something that we have to enforce strictly; the goal
is to catch accidental misuse.

## Test Plan

Clippy found a place where we incorrectly used `std::fs::read_to_string`

crates/ruff_db/src/lib.rs

@@ -1,3 +1,8 @@
+#![warn(
+    clippy::disallowed_methods,
+    reason = "Prefer System trait methods over std methods"
+)]
+
 use crate::files::Files;
 use crate::system::System;
 use crate::vendored::VendoredFileSystem;
@@ -65,6 +70,10 @@ pub trait Db: salsa::Database {
 /// to process work in parallel. For example, to index a directory or checking the files of a project.
 /// ty can still spawn more threads for other tasks, e.g. to wait for a Ctrl+C signal or
 /// watching the files for changes.
+#[expect(
+    clippy::disallowed_methods,
+    reason = "We don't have access to System here, but this is also only used by the CLI and the server which always run on a real system."
+)]
 pub fn max_parallelism() -> NonZeroUsize {
     std::env::var(EnvVars::TY_MAX_PARALLELISM)
         .or_else(|_| std::env::var(EnvVars::RAYON_NUM_THREADS))

crates/ruff_db/src/system.rs

@@ -46,7 +46,7 @@ pub type Result<T> = std::io::Result<T>;
 ///    * File watching isn't supported.
 ///
 /// Abstracting the system also enables tests to use a more efficient in-memory file system.
-pub trait System: Debug {
+pub trait System: Debug + Sync + Send {
     /// Reads the metadata of the file or directory at `path`.
     ///
     /// This function will traverse symbolic links to query information about the destination file.
@@ -197,6 +197,8 @@ pub trait System: Debug {
     fn as_any(&self) -> &dyn std::any::Any;
 
     fn as_any_mut(&mut self) -> &mut dyn std::any::Any;
+
+    fn dyn_clone(&self) -> Box<dyn System>;
 }
 
 #[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]

crates/ruff_db/src/system/os.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::disallowed_methods)]
+
 use super::walk_directory::{
     self, DirectoryWalker, WalkDirectoryBuilder, WalkDirectoryConfiguration,
     WalkDirectoryVisitorBuilder, WalkState,
@@ -255,6 +257,10 @@ impl System for OsSystem {
     fn env_var(&self, name: &str) -> std::result::Result<String, std::env::VarError> {
         std::env::var(name)
     }
+
+    fn dyn_clone(&self) -> Box<dyn System> {
+        Box::new(self.clone())
+    }
 }
 
 impl OsSystem {

crates/ruff_db/src/system/test.rs

@@ -146,6 +146,10 @@ impl System for TestSystem {
     fn case_sensitivity(&self) -> CaseSensitivity {
         self.system().case_sensitivity()
     }
+
+    fn dyn_clone(&self) -> Box<dyn System> {
+        Box::new(self.clone())
+    }
 }
 
 impl Default for TestSystem {
@@ -394,6 +398,13 @@ impl System for InMemorySystem {
     fn case_sensitivity(&self) -> CaseSensitivity {
         CaseSensitivity::CaseSensitive
     }
+
+    fn dyn_clone(&self) -> Box<dyn System> {
+        Box::new(Self {
+            user_config_directory: Mutex::new(self.user_config_directory.lock().unwrap().clone()),
+            memory_fs: self.memory_fs.clone(),
+        })
+    }
 }
 
 impl WritableSystem for InMemorySystem {