Add 'why' explanations throughout documentation

Documentation now explains the purpose behind each concept:
- Why Identifiable? Enables row tracking for animated updates
- Why key paths? Compile-time safety catches typos at build time
- Why setData with animating? Calculates exactly what changed

Updated files:
- README.md: Quick Start with inline explanations
- GettingStarted.md: Step-by-step with reasoning
- QuickStart.md: Brief context for each example

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: pavankataria

README.md

@@ -82,36 +82,36 @@ Display grid-like data with sorting, searching, and smooth animations - all in j
 ```swift
 import SwiftDataTables
 
+// Identifiable enables row tracking for animated updates
 struct Employee: Identifiable {
     let id: String
     let name: String
     let role: String
     let salary: Int
 }
 
-// Define columns with type-safe key paths
+// Key paths provide compile-time safety - typos caught at build time
 let columns: [DataTableColumn<Employee>] = [
     .init("Name", \.name),
     .init("Role", \.role),
-    .init("Salary") { "£\($0.salary)" }
+    .init("Salary") { "£\($0.salary)" }  // Closures for formatted values
 ]
 
-// Create table with columns
 let dataTable = SwiftDataTable(columns: columns)
 view.addSubview(dataTable)
 
-// Load data with animation
+// Rows animate in - scroll position preserved
 dataTable.setData(employees, animatingDifferences: true)
 ```
 
-Update data with animated diffing:
+Update data with animated diffing - SwiftDataTables calculates exactly what changed:
 
 ```swift
-// Fetch and update - rows animate in/out automatically
+// Only changed rows animate - others stay in place
 employees = await api.fetchEmployees()
 dataTable.setData(employees, animatingDifferences: true)
 
-// Append new items
+// New row slides in at the end
 employees.append(newEmployee)
 dataTable.setData(employees, animatingDifferences: true)
 ```

SwiftDataTables/SwiftDataTables.docc/GettingStarted.md

@@ -35,11 +35,11 @@ import SwiftDataTables
 
 ### Step 2: Define Your Model
 
-Create a model conforming to `Identifiable`:
+Your model must conform to `Identifiable`. This enables SwiftDataTables to track individual rows - when you update data, rows animate smoothly (insertions slide in, deletions slide out) instead of the whole table reloading.
 
 ```swift
 struct Employee: Identifiable {
-    let id: Int
+    let id: Int  // Any Hashable type works: Int, String, UUID, etc.
     let name: String
     let role: String
     let city: String
@@ -54,9 +54,11 @@ let employees = [
 
 ### Step 3: Define Columns and Create the Table
 
+Each `DataTableColumn` defines a column header and how to extract the value from your model. Using key paths (`\.name`) gives you compile-time safety - typos are caught at build time, not runtime.
+
 ```swift
 let columns: [DataTableColumn<Employee>] = [
-    .init("Name", \.name),
+    .init("Name", \.name),      // Header: "Name", Value: employee.name
     .init("Role", \.role),
     .init("City", \.city)
 ]

SwiftDataTables/SwiftDataTables.docc/QuickStart.md

@@ -8,7 +8,7 @@ This page provides copy-paste examples for common scenarios. Each example is sel
 
 ## Basic Table
 
-The simplest way to display data:
+The simplest way to display data. Models conform to `Identifiable` so SwiftDataTables can track rows for animated updates:
 
 ```swift
 import SwiftDataTables
@@ -47,7 +47,7 @@ class BasicTableViewController: UIViewController {
 
 ## Type-Safe Table with Models
 
-Use your own model types for compile-time safety:
+Key paths like `\.name` give you compile-time safety - if you rename a property, Xcode catches it immediately instead of failing silently at runtime:
 
 ```swift
 import SwiftDataTables
@@ -87,7 +87,7 @@ class TypedTableViewController: UIViewController {
 
 ## Dynamic Updates with Animation
 
-Update data smoothly without losing scroll position:
+Because your model is `Identifiable`, SwiftDataTables calculates exactly what changed and animates only those rows. Scroll position is preserved - your users won't lose their place:
 
 ```swift
 class DynamicTableViewController: UIViewController {
@@ -210,7 +210,7 @@ config.fixedColumns = .both(left: 1, right: 1)
 
 ## Large Datasets (100k+ Rows)
 
-Optimize for massive datasets:
+For massive datasets, use lazy measurement. Only visible rows are measured; others use the estimated height until they scroll into view. The `prefetchWindow` controls how many rows ahead to pre-measure:
 
 ```swift
 var config = DataTableConfiguration()