fix: make all example programs work correctly

- Add string concatenation support to + operator in typechecker
- Register ADT constructors in both type environment and interpreter
- Bind handlers as values so they can be referenced in run...with
- Fix effect checking to use subset instead of exact match
- Add built-in effects (Console, Fail, State) to run block contexts
- Suppress dead code warnings in diagnostics, modules, parser

Update all example programs with:
- Expected output documented in comments
- Proper run...with statements to execute code

Add new example programs:
- behavioral.lux: pure, idempotent, deterministic, commutative functions
- pipelines.lux: pipe operator demonstrations
- statemachine.lux: ADT-based state machines
- tailcall.lux: tail call optimization examples
- traits.lux: type classes and pattern matching

Add documentation:
- docs/IMPLEMENTATION_PLAN.md: feature roadmap and status
- docs/PERFORMANCE_AND_TRADEOFFS.md: performance analysis

Add benchmarks for performance testing.

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

examples/statemachine.lux

@@ -0,0 +1,83 @@
+// State machine example using algebraic data types
+// Demonstrates pattern matching for state transitions
+//
+// Expected output:
+// Initial light: red
+// After transition: green
+// After two transitions: yellow
+// Door: Closed -> Open -> Closed -> Locked
+
+// Traffic light state machine
+type TrafficLight =
+    | Red
+    | Yellow
+    | Green
+
+fn nextLight(light: TrafficLight): TrafficLight =
+    match light {
+        Red => Green,
+        Green => Yellow,
+        Yellow => Red
+    }
+
+fn canGo(light: TrafficLight): Bool =
+    match light {
+        Green => true,
+        Yellow => false,
+        Red => false
+    }
+
+fn lightColor(light: TrafficLight): String =
+    match light {
+        Red => "red",
+        Yellow => "yellow",
+        Green => "green"
+    }
+
+// Door state machine
+type DoorState =
+    | Open
+    | Closed
+    | Locked
+
+type DoorAction =
+    | OpenDoor
+    | CloseDoor
+    | LockDoor
+    | UnlockDoor
+
+fn applyAction(state: DoorState, action: DoorAction): DoorState =
+    match (state, action) {
+        (Closed, OpenDoor) => Open,
+        (Open, CloseDoor) => Closed,
+        (Closed, LockDoor) => Locked,
+        (Locked, UnlockDoor) => Closed,
+        _ => state
+    }
+
+fn doorStateName(state: DoorState): String =
+    match state {
+        Open => "Open",
+        Closed => "Closed",
+        Locked => "Locked"
+    }
+
+// Test the state machines
+let light1 = Red
+let light2 = nextLight(light1)
+let light3 = nextLight(light2)
+
+let door1 = Closed
+let door2 = applyAction(door1, OpenDoor)
+let door3 = applyAction(door2, CloseDoor)
+let door4 = applyAction(door3, LockDoor)
+
+// Print results
+fn printResults(): Unit with {Console} = {
+    Console.print("Initial light: " + lightColor(light1))
+    Console.print("After transition: " + lightColor(light2))
+    Console.print("After two transitions: " + lightColor(light3))
+    Console.print("Door: " + doorStateName(door1) + " -> " + doorStateName(door2) + " -> " + doorStateName(door3) + " -> " + doorStateName(door4))
+}
+
+let output = run printResults() with {}