Make funAsync wrappers plain functions: drop the double promise layer

The wrapped f is itself async, so an async wrapper allocated a second
promise per call that merely resolved to the callee's promise. The
wrappers (arity-specialized and the generic fallback) are now plain
functions returning the callee's promise directly. Wrappers carry an
own-property async:true marker; fun's dispatch and js.async? test it
alongside instanceof AsyncFunction. The compiler's sync-call detection
is purely syntactic and never inspects wrapper asyncness (audited all
AsyncFunction uses across lib/ and bin/).

Wrapper-level awaited recursion: deno 1.57x, bun 1.40x, node ~1.0x
(V8 already fast-paths the chained layer). Kernel suite improved in
every paired round on node and deno, directionally on bun. All suites
green on node, bun 1.3.14, and deno 2.8.3: backend 369, frontend 10,
kernel 134/134 on all three engines, extensions, ratatoskr e2e, smoke.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Reuben Brooks

lib/frontend.js

@@ -247,7 +247,9 @@ export default async $ => {
    ************************/
 
   await defineTyped('js.array?',     A_boolean, x => asShenBool(Array.isArray(x)));
-  await defineTyped('js.async?',     A_boolean, x => asShenBool(x instanceof AsyncFunction));
+  // funAsync wrappers (lib/runtime.js) are plain functions marked with an
+  // own-property `async: true`; raw async closures are AsyncFunction instances
+  await defineTyped('js.async?',     A_boolean, x => asShenBool(x instanceof AsyncFunction || typeof x === 'function' && x.async === true));
   await defineTyped('js.boolean?',   A_boolean, x => asShenBool(typeof x === 'boolean'));
   await defineTyped('js.defined?',   A_boolean, x => asShenBool(typeof x !== 'undefined'));
   await defineTyped('js.false?',     A_boolean, x => asShenBool(x === false));

lib/runtime.js

@@ -136,31 +136,43 @@ export default (options = {}) => {
       return arguments.length === 4 ? f(a, b, c, d) : funSyncGeneric(f, 4, slice(arguments));
     }
   ];
+  // The async wrappers are deliberately PLAIN functions: the wrapped f is
+  // itself async, so an async wrapper would allocate a second promise per
+  // call that merely resolves to the callee's promise. Returning the
+  // callee's promise directly avoids that double layer; callers always go
+  // through settle/future/await, which handle promise and non-promise
+  // results alike. Since the wrappers are no longer AsyncFunction
+  // instances, they carry an own-property `async: true` marker (set in
+  // funAsync below) that asyncness checks (fun's dispatch here,
+  // js.async? in lib/frontend.js) test alongside instanceof AsyncFunction.
   const funAsyncs = [
-    f => async function () {
+    f => function () {
       return arguments.length === 0 ? f() : funAsyncGeneric(f, 0, slice(arguments));
     },
-    f => async function (a) {
+    f => function (a) {
       return arguments.length === 1 ? f(a) : funAsyncGeneric(f, 1, slice(arguments));
     },
-    f => async function (a, b) {
+    f => function (a, b) {
       return arguments.length === 2 ? f(a, b) : funAsyncGeneric(f, 2, slice(arguments));
     },
-    f => async function (a, b, c) {
+    f => function (a, b, c) {
       return arguments.length === 3 ? f(a, b, c) : funAsyncGeneric(f, 3, slice(arguments));
     },
-    f => async function (a, b, c, d) {
+    f => function (a, b, c, d) {
       return arguments.length === 4 ? f(a, b, c, d) : funAsyncGeneric(f, 4, slice(arguments));
     }
   ];
   const funSync = (f, arity) =>
     arity < funSyncs.length ? funSyncs[arity](f) :
     (...args) => funSyncGeneric(f, arity, args);
   const funAsync = (f, arity) =>
-    arity < funAsyncs.length ? funAsyncs[arity](f) :
-    async (...args) => funAsyncGeneric(f, arity, args);
+    Object.assign(
+      arity < funAsyncs.length ? funAsyncs[arity](f) :
+      (...args) => funAsyncGeneric(f, arity, args),
+      { async: true });
+  const isAsync = f => f instanceof AsyncFunction || f.async === true;
   const fun = (f, arity = f.arity || f.length) =>
-    Object.assign((f instanceof AsyncFunction ? funAsync : funSync)(f, arity), { arity });
+    Object.assign((isAsync(f) ? funAsync : funSync)(f, arity), { arity });
 
   const bounce = (f, ...args) => new Trampoline(f, args);
   const future = async x => {