feat(compiler): add compliance test for struct value init clone

Verifies that initializing a struct value via a composite literal
and assigning it correctly invokes the .clone() method to maintain
Go's value semantics, as described in DESIGN.md.

Signed-off-by: Christian Stewart <christian@aperture.us>

Author: paralin

compliance/COMPLIANCE.md

@@ -22,6 +22,7 @@ The following tests are currently implemented in the `/compliance/tests` directo
 *   **`simple/`**: A basic test covering simple struct definition, field access, method calls, and `println`. (Likely overlaps with others, could be a general integration test).
 *   **`simple_deref_assignment/`**: Tests simple assignment involving pointer dereferencing (`*ptr`), ensuring value copying.
 *   **`struct_field_access/`**: Verifies accessing fields of struct values and struct pointers.
+*   **`struct_value_init_clone/`**: Checks struct initialization via composite literal (`T{...}`) and subsequent assignment, ensuring `.clone()` is used for value semantics.
 *   **`value_type_copy_behavior/`**: Focuses specifically on demonstrating that assigning struct values creates independent copies (value semantics).
 
 Each test should have only three files:

compliance/tests/struct_value_init_clone/expected.log

@@ -0,0 +1,5 @@
+p1: 1 2
+p1 after p2 mod: 1 2
+p2: 10 2
+v after p3 mod: 3 4
+p3: 3 40

compliance/tests/struct_value_init_clone/struct_value_init_clone.go

@@ -0,0 +1,28 @@
+package main
+
+type Point struct {
+	X int
+	Y int
+}
+
+func main() {
+	// Initialize directly
+	p1 := Point{X: 1, Y: 2}
+	println("p1:", p1.X, p1.Y)
+
+	// Assign to another variable (should trigger clone)
+	p2 := p1
+	p2.X = 10 // Modify the copy
+
+	// Print both to show they are independent
+	println("p1 after p2 mod:", p1.X, p1.Y)
+	println("p2:", p2.X, p2.Y)
+
+	// Initialize via variable assignment
+	v := Point{X: 3, Y: 4}
+	p3 := v   // Should trigger clone
+	p3.Y = 40 // Modify the copy
+
+	println("v after p3 mod:", v.X, v.Y)
+	println("p3:", p3.X, p3.Y)
+}

compliance/tests/struct_value_init_clone/struct_value_init_clone.gs.ts

@@ -0,0 +1,35 @@
+// Generated file based on struct_value_init_clone.go
+// Updated when compliance tests are re-run, DO NOT EDIT!
+
+import * as goscript from "@go/builtin";
+
+class Point {
+	public X: number = 0;
+	public Y: number = 0;
+	
+	constructor(init?: Partial<Point>) { if (init) Object.assign(this, init as any); }
+	public clone(): Point { return Object.assign(Object.create(Point.prototype) as Point, this); }
+}
+
+export function main(): void {
+	// Initialize directly
+	let p1 = new Point({ X: 1, Y: 2 }).clone()
+	console.log("p1:", p1.X, p1.Y)
+	
+	// Assign to another variable (should trigger clone)
+	let p2 = p1.clone()
+	p2.X = 10 // Modify the copy
+	
+	// Print both to show they are independent
+	console.log("p1 after p2 mod:", p1.X, p1.Y)
+	console.log("p2:", p2.X, p2.Y)
+	
+	// Initialize via variable assignment
+	let v = new Point({ X: 3, Y: 4 }).clone()
+	let p3 = v.clone() // Should trigger clone
+	p3.Y = 40 // Modify the copy
+	
+	console.log("v after p3 mod:", v.X, v.Y)
+	console.log("p3:", p3.X, p3.Y)
+}
+