Fix recursive type dependency collection issue (#195)

## Summary

- The `DeclCollector` in `generate_ts_definition` only called
`visit_dependencies` on `UserRunConfig`, which per the `ts_rs` API only
visits **direct** type dependencies. Any type referenced indirectly
through a chain of dependencies (e.g. a type nested inside a flattened
struct) would appear in the generated TypeScript output but never be
declared as its own type.
- Fix the collector to recursively call `T::visit_dependencies(self)`
for each visited type, using a `HashSet<TypeId>` to prevent infinite
loops from circular references.
- Add an auto-generated header comment to `run-config.ts` to make it
clear the file should not be edited manually.

### Why this matters

The bug is latent today because all indirect types happen to be
`#[serde(flatten)]`-ed, which causes `ts_rs` to inline their fields
rather than emit separate type declarations. But as soon as a
non-flattened custom type is added at depth > 1 (e.g. a struct
referenced by `EnabledCacheConfig`), the generated TypeScript would
reference that type by name without ever declaring it — producing
invalid TypeScript. The recursive fix future-proofs the collector so any
new nested types are automatically included. The new
`UserGlobalCacheConfig` type (added on `main`) is now correctly emitted
thanks to this fix.

## Test plan
- [x] `cargo test -p vite_task_graph` — all 14 tests pass
- [x] `cargo check` — full project compiles cleanly
- [x] Generated `run-config.ts` includes header and all types

https://claude.ai/code/session_01VQvSgXNnYL8tNWydvtbCvg

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: branchseer

crates/vite_task_graph/run-config.ts

@@ -1,3 +1,5 @@
+// This file is auto-generated by `cargo test`. Do not edit manually.
+
 export type Task = {
   /**
    * The command to run for the task.

crates/vite_task_graph/src/config/user.rs

@@ -205,37 +205,52 @@ impl UserRunConfig {
     #[expect(clippy::disallowed_types, reason = "test code uses std types for convenience")]
     pub fn generate_ts_definition() -> String {
         use std::{
+            any::TypeId,
+            collections::HashSet,
             io::Write,
             process::{Command, Stdio},
         };
 
         use ts_rs::TypeVisitor;
 
-        struct DeclCollector(Vec<String>);
+        struct DeclCollector {
+            decls: Vec<String>,
+            visited: HashSet<TypeId>,
+        }
 
         impl TypeVisitor for DeclCollector {
             fn visit<T: TS + 'static + ?Sized>(&mut self) {
+                if !self.visited.insert(TypeId::of::<T>()) {
+                    return;
+                }
                 // Only collect declarations from types that are exportable
                 // (i.e., have an output path - built-in types like HashMap don't)
                 if T::output_path().is_some() {
-                    self.0.push(T::decl());
+                    self.decls.push(T::decl());
                 }
+                // Recursively visit dependencies of T
+                T::visit_dependencies(self);
             }
         }
 
-        let mut collector = DeclCollector(Vec::new());
+        let mut collector = DeclCollector { decls: Vec::new(), visited: HashSet::new() };
         Self::visit_dependencies(&mut collector);
 
         // Sort declarations for deterministic output order
-        collector.0.sort();
+        collector.decls.sort();
+
+        // Header
+        let mut types: String =
+            "// This file is auto-generated by `cargo test`. Do not edit manually.\n\n".into();
 
         // Export all types
-        let mut types: String = collector
-            .0
+        let dep_types: String = collector
+            .decls
             .iter()
             .map(|decl| vite_str::format!("export {decl}"))
             .collect::<Vec<_>>()
             .join("\n\n");
+        types.push_str(&dep_types);
 
         // Export the main type
         types.push_str("\n\nexport ");