feat(effects): thread parametric Throws[E] type argument (Refs #59) (#204)

STAGE-B cleanup. lower_effect_expr dropped EffCon type args, so
`Throws[MyErr]` collapsed to bare `Throws` — the type parameter the
#59 v1 list calls for (`Throws[E]`) was invisible.

Now the args are mangled into the effect singleton:
`Throws[MyErr]` -> ESingleton "Throws[MyErr]", distinct from
`Throws[Other]` and bare `Throws` under the string-equality
unification of `eff`. Chosen over growing the `eff` ADT with a
parametric variant (which would ripple across every effect operation
in effect.ml/unify.ml — disproportionate for this cleanup). The base
name is still validated via the v1 registry (`Bogus[E]` is still
rejected — verified).

Scope: this is effect *tracking* only. AffineScript does not currently
*enforce* effect-annotation subsumption at call sites (verified: even
`IO` body vs `Mut` decl passes today) — strict effect checking /
handler semantics remain the separately-deferred work (migration-stance
doc; #59 "tracking alone gives most of the value"). This PR makes the
tracked form carry `E`; it does not add enforcement.

dune build clean; dune test --force 253/253, zero regression.

Refs #59

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

lib/typecheck.ml

@@ -452,7 +452,22 @@ and lower_effect_expr (ctx : context) (ee : effect_expr) : eff =
   in
   match ee with
   | EffVar { name; _ } -> resolve name
-  | EffCon ({ name; _ }, _args) -> resolve name
+  | EffCon ({ name; _ }, args) ->
+    (* Parametric effect, e.g. `Throws[MyErr]` (issue #59). Effect
+       *tracking* only: carry the type argument by mangling it into the
+       singleton name, so `Throws[A]`, `Throws[B]` and bare `Throws` are
+       distinct under the string-equality unification of `eff` — without
+       growing the `eff` ADT (which would ripple across every effect
+       operation). The base name is still validated via `resolve`. *)
+    (match resolve name with
+     | ESingleton base when args <> [] ->
+       let arg_str =
+         args
+         |> List.map (fun (TyArg te) -> ty_to_string (lower_type_expr ctx te))
+         |> String.concat ", "
+       in
+       ESingleton (base ^ "[" ^ arg_str ^ "]")
+     | other -> other)
   | EffUnion (e1, e2) ->
     EUnion [lower_effect_expr ctx e1; lower_effect_expr ctx e2]