docs: update nullable type handling and examples in reference documentation

- Removed non-null assertion examples from nullable types documentation to emphasize safe call usage.
- Updated design documentation to reflect the removal of non-null assertion from nullable types description.
- Modified object model documentation to replace non-null assertions with safe call alternatives in casting examples, enhancing clarity on safe operations.

Author: bialger

docs/reference/builtin_types.md

@@ -36,13 +36,12 @@ val hash: Int = greeting.GetHash()
 
 Any primitive type can be made nullable by appending `?` (e.g., `Int?`, `String?`). Nullable types are passed by reference and can hold either a value or `null`.
 
-**Important**: You cannot directly call methods on nullable types using `.` - you must use the safe call operator `?.` or non-null assertion `!!`.
+**Important**: You cannot directly call methods on nullable types using `.` - you must use the safe call operator `?.`.
 
 ```ovum
 val nullableString: String? = "Hello"
 // val length: Int = nullableString.Length()  // ERROR: Cannot call method directly on nullable
 val safeLength: Int = nullableString?.Length() ?: 0  // Correct: Use safe call
-val forcedLength: Int = nullableString!!.Length()    // Correct: Use non-null assertion
 ```
 
 ## Array Types

docs/reference/design.md

@@ -16,7 +16,7 @@ Ovum's core design principles center around:
 ## Key Design Points
 
 * **Strong static typing** with **immutability by default** (`var` required for mutation).
-* **Nullable types** and Kotlin-style null-handling: `Type?`, safe calls `?.`, Elvis `?:`, non-null assertion `!!`.
+* **Nullable types** and Kotlin-style null-handling: `Type?`, safe calls `?.`, Elvis `?:`.
 * **Pure functions** (no side effects, VM-level result caching).
 * **Classes & interfaces**
 

docs/reference/object_model.md

@@ -68,7 +68,7 @@ class Point implements IComparable {
     
     public override fun IsLess(other: Object): Bool {
         if (!(other is Point)) return false
-        val p: Point = (other as Point)!!
+        val p: Point = (other as Point) ?: Point(0, 0)
         if (this.X != p.X) return this.X < p.X
         return this.Y < p.Y
     }
@@ -289,13 +289,13 @@ val comparable: IComparable = point        // Upcast to interface
 
 // Downcasting with type test
 if (obj is Point) {
-    val p: Point = (obj as Point)!!  // Safe after type test
+    val p: Point = (obj as Point) ?: Point(0, 0)
     sys::Print("Point: " + p.ToString())
 }
 
 // Type test operator
 if (shape is ColoredRectangle) {
-    val rect: ColoredRectangle = (shape as ColoredRectangle)!!
+    val rect: ColoredRectangle = (shape as ColoredRectangle) ?: ColoredRectangle(0, 0, "red")
     sys::Print("Rectangle color: " + rect.GetColor())
 }
 ```
@@ -383,7 +383,7 @@ class ResourceManager {
 
 **Type Safety:**
 - Use type tests before casting (`is` before `as`)
-- Prefer safe operations (`?.` and `?:` over `!!`)
+- Prefer safe operations
 - Handle nullable types properly
 
 ```ovum
@@ -395,7 +395,7 @@ interface IWritable { fun Write(content: String): Void }
 fun SafeProcessObject(obj: Object?): Void {
     val result: String = obj?.ToString() ?: "null"
     if (obj is Person) {
-        val person: Person = (obj as Person)!!
+        val person: Person = (obj as Person) ?: Person("Unknown")
         sys::Print("Person: " + person.ToString())
     }
 }