fix(lower): don't double-borrow a read-PARAM passed as a read argument

A read-PARAM already lowers to &T, but the read-arg lowering added another & ->
&&T, producing ill-typed Rust (E0308) when e.g. pushing a read-param into an owned
collection (list_push(&mut v, &&node)) or building a recursive node from read children.
Mirror the existing mut-param case: when the read value is an ident bound to a read
param, emit the ident directly (already &T). Also generalized the managed_handle_arg
retain arms via lower_managed_read_ref. Unblocks ergonomic recursive-IR/graph code.
Regression fixture: tests/fixtures/pass/read-param-into-owned-collection.rss. cargo test green.

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

Author: claude

crates/rsscript/src/rust_lower/lowerer.rs

@@ -3061,7 +3061,7 @@ impl<'a> RustLowerer<'a> {
             && self.expr_lowers_to_managed_handle(value)
         {
             return match effect {
-                DataEffect::Read => format!("&{}", self.lower_expr(value)),
+                DataEffect::Read => self.lower_managed_read_ref(value),
                 DataEffect::Mut => format!("&mut {}", self.lower_expr(value)),
                 DataEffect::Take => self.lower_expr(value),
             };
@@ -3072,7 +3072,7 @@ impl<'a> RustLowerer<'a> {
             && self.expr_lowers_to_managed_handle(value)
         {
             return match effect {
-                DataEffect::Read => format!("&{}", self.lower_expr(value)),
+                DataEffect::Read => self.lower_managed_read_ref(value),
                 DataEffect::Mut => format!("&mut {}", self.lower_expr(value)),
                 DataEffect::Take => self.lower_expr(value),
             };
@@ -3149,6 +3149,14 @@ impl<'a> RustLowerer<'a> {
                         && matches!(value.as_ref(), Expr::ArrayLiteral { .. }))
                 {
                     format!("&{}", self.lower_expr_for_expected_type(value, expected))
+                } else if let Expr::Ident(name, _) = value.as_ref()
+                    && self.param_effects.get(name) == Some(&DataEffect::Read)
+                {
+                    // A `read`-PARAM already lowers to `&T`; passing it on as a `read`
+                    // argument must NOT add another `&` (that produced `&&T` and an
+                    // ill-typed call, e.g. `list_push(&mut v, &&node)`). Mirrors the
+                    // `mut`-param case just below.
+                    rust_value_ident(name)
                 } else {
                     format!("&{}", self.lower_expr(value))
                 }
@@ -3349,6 +3357,20 @@ impl<'a> RustLowerer<'a> {
         }
     }
 
+    // Lower a `read`-effect managed-handle argument to a `&T`. A managed `let` local lowers to
+    // an owned `T`, so it needs a leading `&`. A managed `read`-PARAM already lowers to `&T`
+    // (its Rust param type is a reference), so adding another `&` produced `&&T` and an
+    // ill-typed push into an owned collection (RS1101/RS1102 E0308). Detect the already-ref
+    // case and don't double-borrow.
+    fn lower_managed_read_ref(&mut self, value: &Expr) -> String {
+        if let Expr::Ident(name, _) = value
+            && matches!(self.param_effects.get(name), Some(DataEffect::Read))
+        {
+            return self.lower_expr(value);
+        }
+        format!("&{}", self.lower_expr(value))
+    }
+
     fn call_arg_is_retained(&self, callee: &Callee, arg: &CallArg, _index: usize) -> bool {
         let Some(name) = arg.name.as_deref() else {
             return false;

crates/rsscript/tests/fixtures/pass/read-param-into-owned-collection.rss

@@ -0,0 +1,23 @@
+// Regression: a `read`-PARAM managed value pushed into an owned collection (or passed on as
+// a `read` arg) must not be double-borrowed. Before the fix this emitted `&&T` -> E0308.
+features: local
+
+struct Node derives(Clone, Eq, Hash) {
+    tag: Int
+    src: List<Node>
+}
+
+fn leaf(tag: Int) -> fresh Node { return Node(tag: tag, src: List.new<Node>()) }
+
+fn bin(a: read Node, b: read Node) -> fresh Node {
+    local s = List.new<Node>()
+    List.push(list: mut s, value: read a)
+    List.push(list: mut s, value: read b)
+    return Node(tag: 0, src: take s)
+}
+
+fn main() -> Unit {
+    let p = bin(a: read leaf(tag: 1), b: read leaf(tag: 2))
+    Log.write(message: read Int.to_string(value: read List.len(list: read p.src)))
+    return Unit
+}