Declarations that shadow global `Symbol` break emit for `using` declarations

```ts
// @lib: esnext
// @target: es2024, esnext
export class Symbol {
}

{
using _ = {
[globalThis.Symbol.dispose]() {
console.log("Hello world!");
}
};
}
```

**Expected**: Running the emitted code for both es2024 and esnext display "Hello world!".
**Actual**:

```
> node testfile.js
file:///D:/ts-track-any/testfile.js:10
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
^

TypeError: Symbol.dispose is not defined.
```

Emitted JS code

```js
var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
if (value !== null && value !== void 0) {
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
var dispose, inner;
if (async) {
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
dispose = value[Symbol.asyncDispose];
}
if (dispose === void 0) {
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
dispose = value[Symbol.dispose];
if (async) inner = dispose;
}
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
env.stack.push({ value: value, dispose: dispose, async: async });
}
else if (async) {
env.stack.push({ async: true });
}
return value;
};
var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
return function (env) {
function fail(e) {
env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
env.hasError = true;
}
var r, s = 0;
function next() {
while (r = env.stack.pop()) {
try {
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
if (r.dispose) {
var result = r.dispose.call(r.value);
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
}
else s |= 1;
}
catch (e) {
fail(e);
}
}
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
if (env.hasError) throw env.error;
}
return next();
};
})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
});
export class Symbol {
}
{
const env_1 = { stack: [], error: void 0, hasError: false };
try {
const _ = __addDisposableResource(env_1, {
[globalThis.Symbol.dispose]() {
console.log("Hello world!");
}
}, false);
}
catch (e_1) {
env_1.error = e_1;
env_1.hasError = true;
}
finally {
__disposeResources(env_1);
}
}
```

Bắt đầu với bản tái hiện TypeScript được cung cấp và so sánh JavaScript được phát ra cho các target es2024 và esnext. Kiểm tra helper __addDisposableResource được tạo ra và phần phát ra xung quanh khai báo using; hoàn tất khi cả hai đầu ra đều chạy và hiển thị "Hello world!" mà không gặp lỗi Symbol.dispose.

Do mô hình lập chỉ mục viết ra từ nội dung của issue.