…copes (#22507)

Fixes a semantic mismatch in `async_to_generator` for async methods with parameter default initializers.

Before this change, the transform reused the original method scope as the inner generator scope and moved parameter bindings to the wrapper scope. Scopes created inside parameter defaults were left parented under the generator, even though the transformed AST places those defaults with the wrapper parameters.

For example:

```js
class C {
  async method(value = function fallback() {}) {}
}
```

Conceptually this became:

```js
class C {
  method(value = function fallback() {}) {
    // `value` belongs to this wrapper scope.

    return asyncToGenerator(function* () {
      // Before: the scope for `fallback` was still parented here,
      // because this generator reused the original async method scope.
    })();
  }
}
```

A fresh semantic rebuild from the transformed AST sees it differently:

```js
class C {
  method(value = function fallback() {
    // After rebuild: `fallback` is created from the parameter default,
    // so its direct parent is the wrapper method scope.
  }) {
    return asyncToGenerator(function* () {
      // The generator should only own body scopes.
    })();
  }
}
```

This updates `BindingMover` so that when parameter bindings move to the wrapper, direct scopes created inside parameter-side expressions are reparented there too. It still stops at function/class scope boundaries, so nested body scopes are not traversed or moved.