fix(typecheck): lenient deref so *ref-mode-param type-checks (#128) (#190)

Params declared with a ref/mut mode (e.g. `ref self`, `ref other: Int`)
are lowered to their bare value type — the borrow checker tracks the
actual borrow, not the type. But OpDeref required the operand to unify
with `TRef tv`, so stdlib code reading ref params via `*self`/`*other`
(traits.affine Eq/Ord/Hash/Display impls for Int/Bool) failed with
`Unify (ref tv, Int)`.

Make `*e` peel one borrow layer when e is TRef/TMut/TOwn and act as the
identity on a value type. Real reference types still deref to inner;
value types unchanged -> no regression.

stdlib 16->17/19; 233/233 dune test, zero regression.

Refs #128

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

Author: hyperpolymath

lib/typecheck.ml

@@ -940,6 +940,18 @@ let rec synth (ctx : context) (expr : expr) : ty result =
         | _ ->
           let* () = unify_or_err operand_ty ty_int in
           Ok ty_int)
+     | OpDeref ->
+       (* Lenient deref: `*e` peels one borrow layer when `e` is a
+          reference type, but is the identity on a value type. Params
+          declared with a `ref`/`mut` mode are lowered to their bare
+          value type (the borrow checker tracks the actual borrow), so
+          stdlib code that reads them via `*self` / `*other` must still
+          type-check. Real `TRef`/`TMut`/`TOwn` still peel to the inner
+          type. *)
+       let* operand_ty = synth ctx operand in
+       (match repr operand_ty with
+        | TRef t | TMut t | TOwn t -> Ok t
+        | t -> Ok t)
      | _ ->
        let (operand_ty, result_ty) = type_of_unop op in
        let* () = check ctx operand operand_ty in