fix(tinytorch): tito module start/resume/view leak untracked Jupyter Lab processes

Bug

Every tito module start (without --no-jupyter), resume, or view call
launches a brand new jupyter lab subprocess.Popen with no PID
tracking, no cleanup, and no check for whether one is already running.
Over a normal working session where a student opens several modules,
these accumulate indefinitely: confirmed 45 leaked processes after
routine module-by-module testing, and separately confirmed that a
build-up of ~38 live kernels was enough to make the Jupyter Lab UI
itself sluggish (menu clicks timing out).

Fix

Track the launched Jupyter Lab process's PID in .tito/jupyter.pid.
Before launching a new one, check whether that PID is still alive and
is actually still a jupyter process (guards against a recycled PID
being mistaken for a live server). If so, reuse it: tell the student
which notebook to open in their existing tab instead of spawning
another server. Only launch a new process if no tracked server is
currently running.

Testing

Verified against a fresh dev install with all 20 modules completed:
- First tito module view 01: launches Jupyter Lab as before, records
  its PID.
- Second tito module view 01 (simulating a student opening another
  module in the same session): before the fix, this would spawn a
  second full Jupyter Lab server. After the fix, detects the existing
  PID, prints "Jupyter Lab is already running (pid N)" with the
  notebook to open, and spawns nothing. Confirmed via process listing
  that the jupyter.exe count stayed at 1 across both calls.

Author: Shashank-Tripathi-07

tinytorch/tito/commands/module/workflow.py

@@ -501,6 +501,40 @@ def resume_module(self, module_number: Optional[str] = None) -> int:
 
         return self._open_jupyter(module_name)
 
+    def _jupyter_pid_file(self) -> Path:
+        return self.config.project_root / ".tito" / "jupyter.pid"
+
+    def _running_jupyter_pid(self) -> Optional[int]:
+        """Return the PID of a tito-launched Jupyter Lab server still running, if any."""
+        pid_file = self._jupyter_pid_file()
+        if not pid_file.exists():
+            return None
+        try:
+            pid = int(pid_file.read_text().strip())
+        except (ValueError, OSError):
+            return None
+
+        try:
+            import psutil
+            if not psutil.pid_exists(pid):
+                return None
+            proc = psutil.Process(pid)
+            cmdline = " ".join(proc.cmdline()).lower()
+            if "jupyter" not in cmdline:
+                # PID was recycled by an unrelated process since we last launched
+                return None
+            return pid
+        except ImportError:
+            # No psutil available - fall back to os-level existence check only,
+            # which can't verify it's still actually a Jupyter process.
+            try:
+                os.kill(pid, 0)
+                return pid
+            except OSError:
+                return None
+        except Exception:
+            return None
+
     def _open_jupyter(self, module_name: str) -> int:
         """Open Jupyter Lab for a module."""
         import time
@@ -524,6 +558,20 @@ def _open_jupyter(self, module_name: str) -> int:
                 else:
                     notebook_path = None
 
+            # If a tito-launched Jupyter Lab server is already running, reuse it
+            # instead of spawning another one. Without this, every tito module
+            # start/resume/view call launches its own untracked jupyter lab
+            # process that nothing ever stops, and they accumulate for the rest
+            # of the session.
+            existing_pid = self._running_jupyter_pid()
+            if existing_pid is not None:
+                self.console.print(f"\n[cyan]Jupyter Lab is already running (pid {existing_pid}).[/cyan]")
+                if notebook_path:
+                    self.console.print(f"[dim]Open {notebook_path.name} from the existing Jupyter Lab tab in your browser.[/dim]")
+                else:
+                    self.console.print("[dim]Switch to your existing Jupyter Lab browser tab.[/dim]")
+                return 0
+
             self.console.print(f"\n[cyan]🚀 Opening Jupyter Lab for module {module_name}...[/cyan]")
 
             # Launch Jupyter Lab with the notebook file directly
@@ -541,6 +589,10 @@ def _open_jupyter(self, module_name: str) -> int:
                 errors="replace"
             )
 
+            pid_file = self._jupyter_pid_file()
+            pid_file.parent.mkdir(parents=True, exist_ok=True)
+            pid_file.write_text(str(process.pid))
+
             # Give Jupyter a moment to start and capture the URL
             time.sleep(2)