fix(datagrid): undo replay paths now mark affected rows as changed

Phase B regression: undoRowDeletion / undoRowInsertion / undoBatchRowInsertion
and the replay helpers (reapplyRowDeletion, reapplyCellChange, revertUpdateCell,
updateInsertedCellDirectly, reinsertRow, reinsertBatch) lost the
changedRowIndices.insert that the original DataChangeManager called at the end
of every undo path.

Without it, consumeChangedRowIndices returned empty after undo. The data grid's
reloadAndSyncSelection then fell through to the !hasChanges fallback, doing a
full reloadData over all rows. With 1000 rows this was 33ms per undo. With
larger datasets it gets worse.

Trace before this fix (cellEdit undo to clean state):
  applyDataUndo END mutate=0.08ms callback=0.06ms total=0.19ms
  reloadAndSync VERSION_CHANGED no changes -> full reload
  reloadAndSync total=33.2ms
  updateNSView reloadVersion=8 elapsed=33.5ms

After: changedRows is non-empty, partial reload of just the affected row fires.

Six new regression tests cover each replay method.

Author: datlechin

TablePro/Core/ChangeTracking/PendingChanges.swift

@@ -123,6 +123,7 @@ struct PendingChanges: Equatable {
         guard deletedRowIndices.contains(rowIndex) else { return false }
         removeChange(rowIndex: rowIndex, type: .delete)
         deletedRowIndices.remove(rowIndex)
+        changedRowIndices.insert(rowIndex)
         return true
     }
 
@@ -134,6 +135,7 @@ struct PendingChanges: Equatable {
         insertedRowData.removeValue(forKey: rowIndex)
 
         shiftRowIndicesDown(at: rowIndex)
+        changedRowIndices.insert(rowIndex)
         return true
     }
 
@@ -157,6 +159,7 @@ struct PendingChanges: Equatable {
             removeChange(rowIndex: rowIndex, type: .insert)
             insertedRowIndices.remove(rowIndex)
             insertedRowData.removeValue(forKey: rowIndex)
+            changedRowIndices.insert(rowIndex)
         }
 
         let sortedRemoved = validRows.sorted()
@@ -185,6 +188,7 @@ struct PendingChanges: Equatable {
         modifiedCells.removeValue(forKey: rowIndex)
         appendChange(RowChange(rowIndex: rowIndex, type: .delete, originalRow: originalRow))
         deletedRowIndices.insert(rowIndex)
+        changedRowIndices.insert(rowIndex)
     }
 
     /// Re-apply a cell edit during undo replay (skips undo registration).
@@ -206,6 +210,7 @@ struct PendingChanges: Equatable {
         if let insertIdx = changeIndex[RowChangeKey(rowIndex: rowIndex, type: .insert)] {
             updateInsertedCell(at: insertIdx, columnIndex: columnIndex,
                                columnName: columnName, newValue: newValue)
+            changedRowIndices.insert(rowIndex)
             return
         }
 
@@ -221,6 +226,7 @@ struct PendingChanges: Equatable {
             changeIndex[updateKey] = changes.count - 1
             modifiedCells[rowIndex, default: []].insert(columnIndex)
         }
+        changedRowIndices.insert(rowIndex)
     }
 
     /// Replace an inserted row's cell value during undo replay (no shift, no undo).
@@ -232,6 +238,7 @@ struct PendingChanges: Equatable {
     ) {
         guard let insertIdx = changeIndex[RowChangeKey(rowIndex: rowIndex, type: .insert)] else { return }
         updateInsertedCell(at: insertIdx, columnIndex: columnIndex, columnName: columnName, newValue: newValue)
+        changedRowIndices.insert(rowIndex)
     }
 
     /// Restore a cell's value during undo replay when an existing change matches.
@@ -264,6 +271,7 @@ struct PendingChanges: Equatable {
                 newValue: previousValue
             )
         }
+        changedRowIndices.insert(rowIndex)
     }
 
     /// Insert a synthetic .insert RowChange for undo replay (e.g., after redoing a deletion's undo).
@@ -280,6 +288,7 @@ struct PendingChanges: Equatable {
         if let savedValues {
             insertedRowData[rowIndex] = savedValues
         }
+        changedRowIndices.insert(rowIndex)
     }
 
     /// Insert a batch of rows (for undo replay of a batch deletion's undo).
@@ -302,6 +311,7 @@ struct PendingChanges: Equatable {
             changes.append(RowChange(rowIndex: rowIndex, type: .insert, cellChanges: cellChanges))
             insertedRowIndices.insert(rowIndex)
             insertedRowData[rowIndex] = values
+            changedRowIndices.insert(rowIndex)
         }
         rebuildChangeIndex()
     }

TableProTests/Core/ChangeTracking/PendingChangesTests.swift

@@ -207,6 +207,71 @@ struct PendingChangesSnapshotTests {
     }
 }
 
+@Suite("PendingChanges - changedRowIndices tracking")
+struct PendingChangesChangedRowIndicesTests {
+    @Test("revertUpdateCell records the row as changed")
+    func revertUpdateCellMarksChanged() {
+        var pending = PendingChanges()
+        pending.recordCellChange(
+            rowIndex: 4, columnIndex: 1, columnName: "name",
+            oldValue: "A", newValue: "B"
+        )
+        _ = pending.consumeChangedRowIndices()
+
+        pending.revertUpdateCell(
+            rowIndex: 4, columnIndex: 1, columnName: "name", previousValue: "A"
+        )
+        #expect(pending.consumeChangedRowIndices().contains(4))
+    }
+
+    @Test("undoRowDeletion records the row as changed")
+    func undoRowDeletionMarksChanged() {
+        var pending = PendingChanges()
+        pending.recordRowDeletion(rowIndex: 7, originalRow: ["a"])
+        _ = pending.consumeChangedRowIndices()
+
+        _ = pending.undoRowDeletion(rowIndex: 7)
+        #expect(pending.consumeChangedRowIndices().contains(7))
+    }
+
+    @Test("undoRowInsertion records the row as changed")
+    func undoRowInsertionMarksChanged() {
+        var pending = PendingChanges()
+        pending.recordRowInsertion(rowIndex: 2, values: ["x"])
+        _ = pending.consumeChangedRowIndices()
+
+        _ = pending.undoRowInsertion(rowIndex: 2)
+        #expect(pending.consumeChangedRowIndices().contains(2))
+    }
+
+    @Test("reapplyRowDeletion records the row as changed")
+    func reapplyRowDeletionMarksChanged() {
+        var pending = PendingChanges()
+        _ = pending.consumeChangedRowIndices()
+        pending.reapplyRowDeletion(rowIndex: 3, originalRow: ["a"])
+        #expect(pending.consumeChangedRowIndices().contains(3))
+    }
+
+    @Test("reapplyCellChange records the row as changed")
+    func reapplyCellChangeMarksChanged() {
+        var pending = PendingChanges()
+        _ = pending.consumeChangedRowIndices()
+        pending.reapplyCellChange(
+            rowIndex: 5, columnIndex: 1, columnName: "name",
+            newValue: "X", originalRow: nil
+        )
+        #expect(pending.consumeChangedRowIndices().contains(5))
+    }
+
+    @Test("reinsertRow records the row as changed")
+    func reinsertRowMarksChanged() {
+        var pending = PendingChanges()
+        _ = pending.consumeChangedRowIndices()
+        pending.reinsertRow(rowIndex: 1, columns: ["a"], savedValues: ["v"])
+        #expect(pending.consumeChangedRowIndices().contains(1))
+    }
+}
+
 @Suite("PendingChanges - clear and consume")
 struct PendingChangesLifecycleTests {
     @Test("Clear empties all internal state")