Fix call argument evaluation order and enable await in call arguments

[xeioex]

Why

Spec compliance: ECMAScript requires arguments (including their side effects)
to be evaluated before the callee's callability is checked. The old call lowering
created the frame first, which threw non-callable errors before argument side
effects ran.

Enable await in call arguments and tagged templates: The old frame-first
design made it impossible to suspend on await during argument evaluation
because the frame was already half-constructed. The parser rejected both as a
workaround.

Preserve this for grouped optional calls: (o?.m)() resolved the callee
through the optional chain but dispatched via plain FUNCTION_CALL, losing the
receiver.

Behavioral changes

• Arguments with side effects are now fully evaluated before non-callable errors
  are thrown.
• Constructor arguments are evaluated before checking whether the callee is
  constructable.
• Error messages change from (intermediate value)["x"] is not a function to
  type is not a function (e.g., "number is not a function").
• Backtraces no longer show native frames when arguments throw before reaching
  the native function.
• await in call arguments and tagged templates is now allowed.
• (o?.m)() correctly preserves the receiver.

Examples

// Call ordering — previously threw before evaluating foo()
var fooCalled = false;
function foo() { fooCalled = true; }
var o = {};
try { o.bar(foo()) } catch (e) {}
fooCalled  // true (was false)

// Await in call arguments — previously SyntaxError
async function f() {
    return ({
        g(v) { return v; }
    }).g(await Promise.resolve(2));
}

// Grouped optional chain this — previously TypeError
var o = {x: 5, m: function() { return this.x }};
(o?.m)()  // 5 (was TypeError: cannot get property "x" of undefined)

Test262: +12 tests passed (14457 → 14469)

• language/expressions/call/11.2.3-3_{1,2,4,6,7} — call argument ordering
• language/expressions/new/ctorExpr-isCtor-after-args-eval{,-fn-wrapup} —
  constructor ordering
• language/expressions/await/await-{awaits-thenables,monkey-patched-promise} —
  await in args
• language/expressions/optional-chaining/{member-expression-async-literal,optional-chain-async-*-square-brackets} —
  await + optional chain

[VadimZhestikov]

Looks good. May be useful add next testcases:

// 1. new + awaited args + constructor order

async function f(v, log) { log.push(v); return v; }
async function t1() {
    let log = [];
    function C(a, b) { log.push("ctor"); this.r = a + b; }
    let o = new C(await f(1, log), await f(2, log));
    return JSON.stringify([o.r, log]);
}
t1().then(console.log);
// [3,[1,2,"ctor"]]

// 2. grouped optional call preserves this with awaited arg

async function t2() {
    let o = { x: 5, m(y) { return this.x + y; } };
    return (o?.m)(await Promise.resolve(7));
}
t2().then(console.log);
// 12


// 3. non-callable still evaluates args before throw

async function side(log) { log.push("arg"); return 1; }
async function t3() {
    let log = [];
    try { (0)(await side(log)); } catch (e) { log.push(e.name); }
    return JSON.stringify(log);
}
t3().then(console.log);
// ["arg","TypeError"]


// 4. computed method key evaluated before arg, receiver preserved

async function t4() {
    let log = [];
    let o = {
        x: 9,
        m(v) { log.push("this:" + this.x); return v; }
    };
    async function k(){ log.push("key"); return "m"; }
    async function a(){ log.push("arg"); return 1; }
    await o[await k()](await a());
    return JSON.stringify(log);
}
t4().then(console.log);
// ["key","arg","this:9"]

[VadimZhestikov]

Looks good