fix(stdlib): rename try->attempt, ref->make_ref (#135 slice 6) (#156)

#135 slice 6 — keyword-as-identifier. Two stdlib externs/fns were named
with reserved keywords and could not parse in fn-name position:

- result.affine `fn try<T>` — `try` is the try/catch/finally keyword
  -> renamed `attempt` (its body still uses the real `try { } catch`).
- effects.affine `extern fn ref<T>` — `ref` is the ownership keyword
  -> renamed `make_ref`.

Pure stdlib rename — zero grammar/compiler change, zero risk. No other
stdlib file referenced the old names (verified). Both files now clear
the parse wall and advance to deeper, distinct later-slice defects
(result -> empty-array `(T,Int)` family = slice 7; effects -> generic-
extern kind-checking, separate). Resolve-at-source via rename was the
recommended option in the triage doc (local + safe vs a broad
contextual-keyword grammar change).

Advances #135. Refs #128, #135.

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

Author: hyperpolymath

stdlib/effects.affine

@@ -18,7 +18,9 @@ extern fn read_file(path: String) -> String / io;
 extern fn write_file(path: String, content: String) -> Unit / io;
 
 // Built-in State operations
-extern fn ref<T>(x: T) -> Ref<T> / state;
+// `make_ref` (not `ref`) because `ref` is a reserved ownership keyword;
+// see #135 keyword-as-identifier slice.
+extern fn make_ref<T>(x: T) -> Ref<T> / state;
 extern fn get<T>(r: Ref<T>) -> T / state;
 extern fn set<T>(r: Ref<T>, x: T) -> Unit / state;
 

stdlib/result.affine

@@ -225,8 +225,10 @@ fn result_or<T, E>(a: Result<T, E>, b: Result<T, E>) -> Result<T, E> {
 // Error Handling Patterns
 // ============================================================================
 
-/// Try block emulation - execute function and catch panics as Err
-fn try<T>(f: () -> T) -> Result<T, String> {
+/// Try block emulation - execute function and catch panics as Err.
+/// Named `attempt` (not `try`) because `try` is a reserved keyword
+/// (try/catch/finally); see #135 keyword-as-identifier slice.
+fn attempt<T>(f: () -> T) -> Result<T, String> {
   // TODO: Requires exception handling support
   try {
     Ok(f())