docs: LazyList<T> invalidation via IsValid, TTList<T> properties

Author: davidlastrucci

docs/guide/context.md

@@ -267,7 +267,7 @@ Create a Unit of Work session. See [Sessions](sessions.md):
 LSession := LContext.CreateSession<TPerson>(LPersonList);
 ```
 
-An overload accepts a `TTLazyList<T>` directly. After `ApplyChanges` the lazy list is invalidated so it reloads from the database on next access:
+When the list comes from a lazy collection (a `TTLazyList<T>` field exposed as `TTList<T>`), `ApplyChanges` invalidates the underlying lazy list so it reloads from the database on next access:
 
 ```pascal
 LSession := LContext.CreateSession<TOrder>(LCustomer.Orders);

docs/guide/cookbook.md

@@ -224,14 +224,23 @@ type
     // ...
     [TDetailColumn('ID', 'OrderID')]
     FDetails: TTLazyList<TOrderDetail>;
+
+    function GetDetails: TTList<TOrderDetail>;
   public
-    property Details: TTLazyList<TOrderDetail> read FDetails;
+    property Details: TTList<TOrderDetail> read GetDetails;
   end;
 ```
 
+```pascal
+function TOrder.GetDetails: TTList<TOrderDetail>;
+begin
+  Result := FDetails.List;
+end;
+```
+
 ```pascal
 LOrder := LContext.Get<TOrder>(LOrderID);
-for LDetail in LOrder.Details.Value do
+for LDetail in LOrder.Details do
   Writeln(Format('  %s x%d', [LDetail.ProductName, LDetail.Quantity]));
 ```
 

docs/guide/lazy-loading.md

@@ -89,21 +89,21 @@ end;
 
 ### Behavior
 
-- The list is loaded on the first access to `.List`. A SELECT query is executed with a filter matching the foreign key column to the parent's ID.
+- The list is loaded on first access. A SELECT query is executed with a filter matching the foreign key column to the parent's ID.
 - `AddEntity` creates a new entity via the context and adds it to the list:
 
 ```pascal
 LNewEmployee := FEmployees.AddEntity;
 LNewEmployee.Firstname := 'Alice';
 ```
 
-- When the parent's ID changes, the cached list is freed and will be reloaded on next access.
+- When the parent's ID changes, the cached list is invalidated and will be reloaded on next access.
 
 ### Invalidation and Sessions
 
-`TTLazyList<T>` implements the `ITLazyList<T>` interface (`Invalidate`, `GetList`). Calling `Invalidate` discards the cached list so the next access re-runs the SELECT.
+The cached list carries an `IsValid` flag. When it is cleared -- for example when the parent's ID changes -- the next access re-runs the SELECT and refills the same list instance in place.
 
-This integrates with the Unit of Work: `CreateSession<T>` has an overload that takes a `TTLazyList<T>` directly. When the session's `ApplyChanges` completes, it invalidates the lazy list automatically, so the in-memory collection reflects the persisted state on the next read:
+This integrates with the Unit of Work: the collection is a `TTList<T>`, so you pass it straight to `CreateSession<T>`. When the session's `ApplyChanges` completes, it invalidates the underlying lazy list automatically, so the in-memory collection reflects the persisted state on the next read:
 
 ```pascal
 var LSession := LContext.CreateSession<TEmployee>(LDepartment.Employees);

docs/guide/sessions.md

@@ -29,13 +29,13 @@ end;
 
 ## Creating from a Lazy List
 
-`CreateSession<T>` also accepts a `TTLazyList<T>` (via the `ITLazyList<T>` interface) instead of a plain list. This is convenient for editing the children of a parent entity loaded through [lazy loading](lazy-loading.md):
+A lazy collection exposes its children as a `TTList<T>`, which you can pass straight to `CreateSession<T>`. This is convenient for editing the children of a parent entity loaded through [lazy loading](lazy-loading.md):
 
 ```pascal
 var LSession := LContext.CreateSession<TEmployee>(LDepartment.Employees);
 ```
 
-When `ApplyChanges` completes, the session invalidates the lazy list, so the parent's collection reloads from the database on next access and stays in sync with the persisted state.
+When `ApplyChanges` completes, the session invalidates the underlying lazy list, so the parent's collection reloads from the database on next access and stays in sync with the persisted state.
 
 ## How It Works