Fix evalLowLevelLambda to handle non-closure layouts from polymorphic contexts

When evaluating a low-level lambda (like List.append) in a polymorphic context
where the type is constrained but not yet fully resolved, getRuntimeLayout
could return a non-closure layout (like Dec for an unresolved flex var).
This caused the closure header to be written to memory allocated with the
wrong layout, leading to type confusion when the value was later used.

The fix applies the same guard that evalLambda already has: check if the
layout is not a closure and create an empty captures closure layout if needed.

Fixes #9054

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

Author: rtfeldman

src/eval/interpreter.zig

@@ -13676,7 +13676,14 @@ pub const Interpreter = struct {
             const ct_var = can.ModuleEnv.varFrom(expr_idx);
             break :blk try self.translateTypeVar(self.env, ct_var);
         };
-        const closure_layout = try self.getRuntimeLayout(rt_var);
+        var closure_layout = try self.getRuntimeLayout(rt_var);
+        if (closure_layout.tag != .closure) {
+            // For recursive closures or polymorphic contexts, the type translation may return
+            // a non-closure layout (like Dec for an unresolved flex var). In evalLowLevelLambda,
+            // we KNOW we need a closure layout, so create one with empty captures.
+            const empty_captures_idx = try self.runtime_layout_store.ensureEmptyRecordLayout();
+            closure_layout = layout.Layout.closure(empty_captures_idx);
+        }
         const value = try self.pushRaw(closure_layout, 0, rt_var);
         self.registerDefValue(expr_idx, value);
         if (value.ptr) |ptr| {

test/fx/recursive_where_clause.roc

@@ -0,0 +1,19 @@
+app [main!] { pf: platform "./platform/main.roc" }
+
+import pf.Stdout
+
+compress : List(a) -> List(a) where [a.is_eq : a, a -> Bool]
+compress = |l|
+    match l {
+        [] => []
+        [e] => [e]
+        [e1, e2, .. as rest] => {
+            rest_compression = compress(List.concat([e2], rest))
+            if e1 == e2 { rest_compression } else { List.concat([e1], rest_compression) }
+        }
+    }
+
+main! = || {
+    result = compress([1, 1, 2, 2, 2, 3, 3, 1, 1])
+    Stdout.line!(Str.inspect(result))
+}