rsscript: read-of-qualified-call parse fix; remove resolved tracking docs

`read module.fn(args)` in argument position misparsed: `read` bound to the module
path's first segment as a receiver call, dropping the effect (RS0202). A
module-receiver receiver call always carries an explicit effect (bare module
calls parse as Callee::Qualified), so module_isolation now converts it to the
qualified free call and re-applies the effect to the whole call — `read m.fn()`
== `read (m.fn())` == `read flat()`. Verified at parity; receiver-call shorthand
on real value receivers is unaffected.

This was the last open request. All docs/requests/*.md and
docs/tinygrad-port-todo.md are now resolved, so they're removed (history retains
their write-ups).

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

Author: olwang

crates/rsscript/src/syntax/module_isolation.rs

@@ -606,7 +606,44 @@ impl Resolver {
                     *name = mangled;
                 }
             }
-            Expr::Call { callee, args, .. } => {
+            Expr::Call { callee, args, span } => {
+                // `<effect> module.fn(args)` parses as a receiver call, but when the
+                // receiver names a module it is a module-qualified free call. The
+                // effect was written for the *call*, not the module, so convert it
+                // and re-apply the effect to the whole call: `read m.fn()` becomes
+                // `read (m__fn())`, identical to `read flat()` and `read (m.fn())`.
+                // A receiver call always carries an explicit effect (bare module
+                // calls parse as `Callee::Qualified`, handled below), so this never
+                // affects value-position calls.
+                if let Callee::ReceiverCall {
+                    receiver,
+                    method,
+                    effect,
+                } = callee
+                    && let Some(prefix) = module_path_of_receiver(receiver, scope)
+                    && self
+                        .module_defs
+                        .get(&prefix)
+                        .is_some_and(|names| names.contains(method))
+                {
+                    let effect = *effect;
+                    let mangled = format!("{prefix}{MODULE_SEP}{method}");
+                    for arg in args.iter_mut() {
+                        self.rewrite_expr(&mut arg.value, file, scope);
+                    }
+                    let call_args = std::mem::take(args);
+                    let span = span.clone();
+                    *expr = Expr::Effect {
+                        effect,
+                        value: Box::new(Expr::Call {
+                            callee: Callee::Name(mangled),
+                            args: call_args,
+                            span: span.clone(),
+                        }),
+                        span,
+                    };
+                    return;
+                }
                 self.rewrite_callee(callee, file, scope);
                 for arg in args {
                     self.rewrite_expr(&mut arg.value, file, scope);

crates/rsscript/tests/checker_frontend/misc.rs

@@ -64,6 +64,31 @@ fn qualified_variant_in_match_pattern_checks_clean() {
     );
 }
 
+#[test]
+fn read_qualified_module_call_parses_as_read_of_call() {
+    // `read m.fn(args)` in argument position is read-of-the-call, not a receiver
+    // call on the module — identical to `read flat()` / `read (m.fn())`.
+    let diagnostics = analyze_sources_with_interfaces(
+        &[
+            ("m.rss", "module m\n\nfn order_names() -> fresh String { return \"x\" }\n"),
+            (
+                "app.rss",
+                concat!(
+                    "module app\n\n",
+                    "fn sink(v: read String) -> Unit { return Unit }\n\n",
+                    "fn use_it() -> Unit { return sink(v: read m.order_names()) }\n",
+                ),
+            ),
+        ],
+        &[],
+    );
+    assert_eq!(
+        diagnostics,
+        Vec::new(),
+        "`read m.fn()` should resolve as read-of-call: {diagnostics:?}"
+    );
+}
+
 #[test]
 fn glob_import_brings_module_symbols_into_scope() {
     // `use ops.*` imports the module's type, const, and functions; bare variants