refactor: consolidate CellManager and NotebookDocument (#9405)

## Summary

`CellManager` now wraps a `NotebookDocument` instead of holding its own
dict of `CellData`, and `Session.document` is a property that reads
through `cell_manager.document`. Removes a class of drift bugs where the
two were synced once at session startup and then diverged across save,
file-watch reload, and code-mode autosave.

## What changed

- **`CellManager` wraps the document.** Removed `_cell_data` dict is
gone; `get_cell_data` returns a fresh synthesized view each call.
- **`Session.document` is a `@property`** returning
`app.cell_manager.document`. No more manual rebinding when the manager
or app is swapped. Save-endpoint workaround removed.
- **Transitional helpers** preserve identity of `_document` and
`_compiled_cells` for callers that still rebuild the cell list as a
unit: `CellManager._replace_state_from` and
`NotebookDocument._replace_cells`. `InternalApp.with_data` uses the
former. A follow-up will route both through `Transaction.apply`.
- **File-watch reload bridge.** `AppFileManager.reload()` still swaps in
a fresh app, so the coordinator now snapshots `prev_document` before the
swap, builds the diff `Transaction`, and passes it to the strategy. A
follow-up will rework `reload()` to apply the diff in place.

## Tests
Invariants for the document property, `get_cell_data` view freshness,
`_replace_state_from` identity preservation, `_compiled_cells` lockstep
rekeying (with an **xfail** for the latent inner `Cell._cell.cell_id`
mismatch — separate follow-up), `_replace_cells` version bump, and
`InternalApp.with_data` identity + compiled-cell carryover.

Author: kirangadhave

marimo/_ast/app.py

@@ -294,7 +294,7 @@ def clone(self) -> App:
             strict=False,
         ):
             cell = None
-            cell_data = self._cell_manager._cell_data.get(cell_id)
+            cell_data = self._cell_manager.get_cell_data(cell_id)
             new_cell_id = app._cell_manager.create_cell_id()
             # If the cell exists, the cell data should be set (ie not None).
             if cell_data is not None:
@@ -1014,23 +1014,31 @@ def with_data(
         names: Iterable[str],
         configs: Iterable[CellConfig],
     ) -> InternalApp:
-        new_cell_manager = CellManager()
+        """Rewrite the cell list from textual fields, in place.
+
+        Mutates ``self._app._cell_manager`` rather than replacing it,
+        so any caller holding ``app.cell_manager`` or
+        ``app.cell_manager.document`` (notably ``Session.document``)
+        continues to see live state without rebinding.
+
+        Cells that survive the rewrite keep their compiled ``Cell``;
+        callers from save flows pass the frontend's snapshot, which
+        renames/reorders/reconfigures cells but doesn't recompile.
+        """
+        cm = self._app._cell_manager
+        prev_compiled = dict(cm._compiled_cells)
+        rebuilt = CellManager(prefix=cm.prefix)
         for cell_id, code, name, config in zip(
             cell_ids, codes, names, configs, strict=False
         ):
-            cell = None
-            # If the cell exists, the cell data should be set.
-            cell_data = self._app._cell_manager._cell_data.get(cell_id)
-            if cell_data is not None:
-                cell = cell_data.cell
-            new_cell_manager.register_cell(
+            rebuilt.register_cell(
                 cell_id=cell_id,
                 code=code,
                 name=name,
                 config=config,
-                cell=cell,
+                cell=prev_compiled.get(cell_id),
             )
-        self._app._cell_manager = new_cell_manager
+        cm._replace_state_from(rebuilt)
         return self
 
     async def run_cell_async(
@@ -1073,7 +1081,7 @@ def to_ir(self) -> NotebookSerializationV1:
                     name=cell_data.name,
                     options=cell_data.config.asdict(),
                 )
-                for cell_data in self._app._cell_manager._cell_data.values()
+                for cell_data in self._app._cell_manager.cell_data()
             ],
             app=AppInstantiation(
                 options=self._app._config.asdict(),