refactor: replace LazyTaskGraph enum with struct + Option to remove unreachable!

Restructure LazyTaskGraph from a two-variant enum (Uninitialized/Initialized)
to a struct with an Option<IndexedTaskGraph>. This eliminates the unreachable!
in the double-match pattern that was needed after mutating self from
Uninitialized to Initialized.

The remaining unreachable! calls in the codebase (fspy_preload_windows
buffer size invariant, vite_path strip_prefix mathematical invariant) are
genuine logical invariants that cannot be expressed in the type system.

Author: branchseer

crates/vite_task/src/session/mod.rs

@@ -29,27 +29,23 @@ use vite_workspace::{WorkspaceRoot, find_workspace_root};
 use crate::cli::{CacheSubcommand, Command, RunCommand, RunFlags};
 
 #[derive(Debug)]
-enum LazyTaskGraph<'a> {
-    Uninitialized { workspace_root: WorkspaceRoot, config_loader: &'a dyn UserConfigLoader },
-    Initialized(IndexedTaskGraph),
+struct LazyTaskGraph<'a> {
+    workspace_root: WorkspaceRoot,
+    config_loader: &'a dyn UserConfigLoader,
+    graph: Option<IndexedTaskGraph>,
 }
 
 #[async_trait::async_trait(?Send)]
 impl TaskGraphLoader for LazyTaskGraph<'_> {
     async fn load_task_graph(
         &mut self,
     ) -> Result<&vite_task_graph::IndexedTaskGraph, TaskGraphLoadError> {
-        Ok(match self {
-            Self::Uninitialized { workspace_root, config_loader } => {
-                let graph = IndexedTaskGraph::load(workspace_root, *config_loader).await?;
-                *self = Self::Initialized(graph);
-                match self {
-                    Self::Initialized(graph) => &*graph,
-                    Self::Uninitialized { .. } => unreachable!(),
-                }
-            }
-            Self::Initialized(graph) => &*graph,
-        })
+        if self.graph.is_none() {
+            let graph = IndexedTaskGraph::load(&self.workspace_root, self.config_loader).await?;
+            self.graph = Some(graph);
+        }
+        // Unwrap is safe: the block above ensures `self.graph` is `Some`.
+        Ok(self.graph.as_ref().unwrap())
     }
 }
 
@@ -200,9 +196,10 @@ impl<'a> Session<'a> {
         // Cache is lazily initialized on first access to avoid SQLite race conditions
         Ok(Self {
             workspace_path: Arc::clone(&workspace_root.path),
-            lazy_task_graph: LazyTaskGraph::Uninitialized {
+            lazy_task_graph: LazyTaskGraph {
                 workspace_root,
                 config_loader: callbacks.user_config_loader,
+                graph: None,
             },
             envs: Arc::new(envs),
             cwd,
@@ -414,11 +411,8 @@ impl<'a> Session<'a> {
         Arc::clone(&self.workspace_path)
     }
 
-    pub const fn task_graph(&self) -> Option<&TaskGraph> {
-        match &self.lazy_task_graph {
-            LazyTaskGraph::Initialized(graph) => Some(graph.task_graph()),
-            LazyTaskGraph::Uninitialized { .. } => None,
-        }
+    pub fn task_graph(&self) -> Option<&TaskGraph> {
+        self.lazy_task_graph.graph.as_ref().map(IndexedTaskGraph::task_graph)
     }
 
     pub const fn envs(&self) -> &Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>> {