Anonymous Symbol Properties

Nobody has claimed this yet.

### 🔍 Search Terms

"anonymous symbol properties"
"anonymous unique symbol"
"inline unique symbol"
"unique symbol property key"
"computed property unique symbol"
"symbol branding"

### ✅ Viability Checklist

- [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
- [x] This wouldn't change the runtime behavior of existing JavaScript code
- [x] This could be implemented without emitting different JS based on the types of the expressions
- [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
- [x] This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
- [x] This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

### ⭐ Suggestion

Allow `unique symbol` keys to be declared inline at the property declaration site.

### 📃 Motivating Example

**Current code:**
```ts
declare const brand: unique symbol;
type UserId = string & { readonly [brand]: "UserId" };
```

**Proposed code:**
```ts
type UserId = string & { readonly [brand: unique symbol]: "UserId" };
```

Each inline declaration would create a fresh symbol identity, equivalent to declaring a separate `unique symbol` and using it as the computed property key.

This is useful when a `unique symbol` property key is needed only once and does not need to be referenced independently. Common examples include phantom properties used for branded or refined types.

### 💻 Use Cases

1. What do you want to use this for?
Declaring single-use `unique symbol` property keys inline, particularly for phantom properties used by branded or refined types.

2. What shortcomings exist with current approaches?
The current approach requires introducing a value-level declaration solely to provide a unique identity for a type-level property key. For single-use symbol keys, this creates an otherwise unnecessary binding in the surrounding scope.

3. What workarounds are you using in the meantime?
Declaring a separate `unique symbol` value and using it as a computed property key.

Start from the current and proposed type declarations in the issue and trace how TypeScript handles computed property keys and unique symbol identities. Done means accepting inline unique symbol property keys, giving each declaration a fresh identity, and preserving runtime JavaScript output; the issue does not name implementation files or tests.

Written by the indexing model from the issue text.