feat(rss): payload-less sum value params + == on read-enum params

GAP1: a payload-less (fieldless) sum is Copy-like, so a by-value param fn f(o: Op) no longer
requires read/mut/take (analyzer is_payloadless_sum_type exemption), and f(o: A) works. GAP2:
o == A on a read-bound enum param lowered to &Op == Op (E0277); now derefs one side when a
read enum-param ref is compared to a sum value (mirrors field-access enum compare). Removes two
recurring workarounds in the tinygrad port. Full cargo test -p rsscript green (25 targets, 0
failed). Subagent-produced, applied + reverified.

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

Author: claude

crates/rsscript/src/analyzer.rs

@@ -2320,6 +2320,23 @@ impl Analyzer<'_> {
         }
     }
 
+    /// A payload-less sum type (every variant carries no fields) behaves like a
+    /// plain C-style enum: it is cheap to copy and may be passed by value without
+    /// an explicit data effect, mirroring how primitive Copy types are treated.
+    fn is_payloadless_sum_type(&self, ty: &TypeRef) -> bool {
+        if !ty.args.is_empty() || ty.is_noescape || ty.is_owned || ty.is_fresh {
+            return false;
+        }
+        let root = type_root_name(&ty.name);
+        if self.hir.type_kind(root) != Some(HirTypeKind::Sum) {
+            return false;
+        }
+        match self.sum_variants_for_type(root) {
+            Some(variants) => variants.iter().all(|(_, fields)| fields.is_empty()),
+            None => false,
+        }
+    }
+
     fn sum_variants_for_type(&self, root: &str) -> Option<Vec<(String, Vec<FieldInfo>)>> {
         for item in &self.syntax_program.items {
             if let Item::SumType(sum) = item
@@ -2491,6 +2508,7 @@ impl Analyzer<'_> {
                     && !type_ref_has_surface_reference(&param.ty, self.tokens)
                     && !type_ref_contains_name(&param.ty, "Fd")
                     && !is_copy_type(&param.ty)
+                    && !self.is_payloadless_sum_type(&param.ty)
                 {
                     self.diagnostics.push(
                         Diagnostic::error(

crates/rsscript/src/rust_lower/lowerer.rs

@@ -2235,6 +2235,28 @@ impl<'a> RustLowerer<'a> {
                         self.lower_string_comparison_operand(right)
                     );
                 }
+                if matches!(op, "==" | "!=") {
+                    // A `read`-bound enum parameter lowers to `&Op`; comparing it
+                    // against a sum *value* (e.g. a bare variant) needs a deref so
+                    // both sides are `Op`. Mirrors how field-access enum comparison
+                    // already lowers to a value on both sides.
+                    let left_ref = self.is_enum_read_ref_operand(left);
+                    let right_ref = self.is_enum_read_ref_operand(right);
+                    if left_ref && !right_ref && self.is_enum_value_operand(right) {
+                        return format!(
+                            "*{} {op} {}",
+                            self.lower_binary_operand(left, binary_op, false),
+                            self.lower_binary_operand(right, binary_op, true)
+                        );
+                    }
+                    if right_ref && !left_ref && self.is_enum_value_operand(left) {
+                        return format!(
+                            "{} {op} *{}",
+                            self.lower_binary_operand(left, binary_op, false),
+                            self.lower_binary_operand(right, binary_op, true)
+                        );
+                    }
+                }
                 format!(
                     "{} {op} {}",
                     self.lower_binary_operand(left, binary_op, false),
@@ -3899,6 +3921,38 @@ impl<'a> RustLowerer<'a> {
                 .is_some_and(|ty| self.is_class_type(&ty))
     }
 
+    /// True when this operand is a `read`-bound parameter whose type is a
+    /// user-defined sum type. Such a parameter lowers to `&Op`, so comparing it
+    /// against a sum *value* (e.g. a bare variant literal) needs a deref.
+    fn is_enum_read_ref_operand(&self, expr: &Expr) -> bool {
+        let Expr::Ident(name, _) = expr else {
+            return false;
+        };
+        if self.param_effects.get(name) != Some(&DataEffect::Read) {
+            return false;
+        }
+        let Some(ty) = self.value_types.get(name) else {
+            return false;
+        };
+        ty.args.is_empty() && self.is_sum_type_name(&ty.name)
+    }
+
+    /// True when this operand is a sum *value* that lowers by value (not behind a
+    /// reference) — most commonly a bare variant literal such as `A`.
+    fn is_enum_value_operand(&self, expr: &Expr) -> bool {
+        match expr {
+            Expr::Ident(name, _) => self.find_sum_type_for_variant(name).is_some(),
+            _ => false,
+        }
+    }
+
+    fn is_sum_type_name(&self, name: &str) -> bool {
+        self.program
+            .items
+            .iter()
+            .any(|item| matches!(item, Item::SumType(sum) if sum.name == name))
+    }
+
     fn is_string_comparison_operand(&self, expr: &Expr) -> bool {
         matches!(expr, Expr::String(_, _) | Expr::MultilineString(_, _))
             || self