feat(lang): implement record field access with dot notation (Task #24)

Added complete support for record/struct field access and record literals:

Parser changes:
- Added parse_record_literal() for TypeName { field: value } syntax
- Added Dot token to Call precedence level
- Modified parse_infix() to handle field access (record.field)
- Modified parse_prefix() to detect record literals

TypeChecker changes:
- Changed TypeInfo::Record from HashMap to String (nominal typing)
- Added type_defs field to track struct definitions
- Added type_from_ast() to convert AST types to TypeInfo
- Implemented field access type inference with struct field lookup
- Implemented record literal type checking with field validation

Interpreter changes:
- Added FieldAccess evaluation (looks up field in Record value)
- Added RecordLiteral evaluation (builds HashMap from field expressions)

Linter changes:
- Added linter cases for FieldAccess and RecordLiteral

Other:
- Updated .tool-versions (rust nightly for better tooling)
- Added examples/28_record_fields.woke and examples/29_simple_record.woke
- Created STATE.scm with comprehensive project state tracking
- Added SPDX headers to all source files (PMPL-1.0-or-later)

All examples build and run successfully. Type checking ensures field access
safety and record literal correctness at compile time.

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

Author: Test

benches/vm_bench.rs

@@ -1,10 +1,11 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
 //! WokeLang VM Performance Benchmarks
 //!
 //! Benchmarks comparing interpreter vs VM execution.
 
 use std::time::Instant;
+use wokelang::vm::{compile, run_vm};
 use wokelang::{Interpreter, Lexer, Parser};
-use wokelang::vm::{run_vm, compile};
 
 fn bench_interpreter(source: &str, iterations: u32) -> std::time::Duration {
     let start = Instant::now();

examples/28_record_fields.woke

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// Example demonstrating record field access with dot notation
+
+#verbose on;
+
+// Define a Person struct
+type Person = {
+    name: String,
+    age: Int
+};
+
+to main() {
+    // Create a person using record literal syntax
+    remember person = Person {
+        name: "Alice",
+        age: 30
+    };
+
+    // Access fields using dot notation
+    print("Name:");
+    print(person.name);
+
+    print("Age:");
+    remember personAge = person.age;
+    print(toString(personAge));
+
+    give back 0;
+}

examples/29_simple_record.woke

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// Simple record test
+
+#verbose on;
+
+type Point = {
+    x: Int,
+    y: Int
+};
+
+to main() {
+    remember p = Point {
+        x: 10,
+        y: 20
+    };
+
+    print(toString(p.x));
+    print(toString(p.y));
+
+    give back 0;
+}

src/ast/mod.rs

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
 use std::ops::Range;
 
 /// Source span for error reporting
@@ -284,6 +285,10 @@ pub enum Expr {
     Unwrap(Box<Spanned<Expr>>),
     /// Lambda/closure: `|x, y| -> expr` or `|x, y| { ... }`
     Lambda(LambdaExpr),
+    /// Field access: `record.field`
+    FieldAccess(Box<Spanned<Expr>>, String),
+    /// Record literal: `Person { name: "Alice", age: 30 }`
+    RecordLiteral(String, Vec<(String, Spanned<Expr>)>),
 }
 
 /// Binary operators

src/codegen/mod.rs

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
 mod wasm;
 
 pub use wasm::WasmCompiler;

src/ffi/c_api.rs

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
 //! C-compatible API for WokeLang
 //!
 //! This module provides extern "C" functions that can be called from Zig, C,

src/ffi/mod.rs

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
 //! Foreign Function Interface for WokeLang
 //!
 //! This module provides a C-compatible API that can be used from Zig, C, or any