This is the first step towards removing the expensive `rename_non_root_symbol`
method. Changes include:

1. Add new fields to Renamer struct:
   - `entry_module_idx`: Track the entry module index
   - `entry_module`: Reference to entry module's symbol database
   - `module_used_names`: Cache of non-root symbol names per module
   - `used_names`: Track names used during renaming

2. Update `Renamer::new()` to accept `base_module_index` parameter and
   pre-cache entry module symbol names

3. Add helper methods for the new algorithm:
   - `is_entry_root_binding()`: Check if name is entry module's root binding
   - `is_name_available()`: Check if name doesn't conflict with existing names
   - `get_or_create_module_used_names()`: Lazily compute non-root symbol names

These changes prepare for eliminating the expensive nested scope iteration
in `rename_non_root_symbol` by making `add_symbol_in_root_scope` smarter
about which names to avoid.

Part of reworking PR rolldown#4014 for ~4% performance improvement.

Co-Authored-By: Claude Opus 4.5 <[email protected]>

This is the first step towards removing the expensive `rename_non_root_symbol`
method. Changes include:

1. Add new fields to Renamer struct:
   - `entry_module_idx`: Track the entry module index
   - `entry_module`: Reference to entry module's symbol database
   - `module_used_names`: Cache of non-root symbol names per module
   - `used_names`: Track names used during renaming

2. Update `Renamer::new()` to accept `base_module_index` parameter and
   pre-cache entry module symbol names

3. Add helper methods for the new algorithm:
   - `is_entry_root_binding()`: Check if name is entry module's root binding
   - `is_name_available()`: Check if name doesn't conflict with existing names
   - `get_or_create_module_used_names()`: Lazily compute non-root symbol names

These changes prepare for eliminating the expensive nested scope iteration
in `rename_non_root_symbol` by making `add_symbol_in_root_scope` smarter
about which names to avoid.

Part of reworking PR rolldown#4014 for ~4% performance improvement.

Co-Authored-By: Claude Opus 4.5 <[email protected]>

This is the first step towards removing the expensive `rename_non_root_symbol`
method. Changes include:

1. Add new fields to Renamer struct:
   - `entry_module_idx`: Track the entry module index
   - `entry_module`: Reference to entry module's symbol database
   - `module_used_names`: Cache of non-root symbol names per module
   - `used_names`: Track names used during renaming

2. Update `Renamer::new()` to accept `base_module_index` parameter and
   pre-cache entry module symbol names

3. Add helper methods for the new algorithm:
   - `is_entry_root_binding()`: Check if name is entry module's root binding
   - `is_name_available()`: Check if name doesn't conflict with existing names
   - `get_or_create_module_used_names()`: Lazily compute non-root symbol names

These changes prepare for eliminating the expensive nested scope iteration
in `rename_non_root_symbol` by making `add_symbol_in_root_scope` smarter
about which names to avoid.

Part of reworking PR rolldown#4014 for ~4% performance improvement.

Co-Authored-By: Claude Opus 4.5 <[email protected]>

…ot_symbol` pass (#7867)

## Summary

This PR optimizes the symbol renamer by eliminating the expensive
`rename_non_root_symbol` pass and fixes a bug that could generate
duplicate declarations.

### Background
This is a rework of #4014, split into atomic commits for easier review.
The original PR was rejected due to too many changes at once. Issue
#6586 has since been fixed by #7859, but the performance optimization
approach from #4014 still provides significant gains.

### Key Changes

**1. Eliminate `rename_non_root_symbol` pass**
- During root scope renaming, check against nested scopes upfront via
`is_name_available()`
- Most nested scope symbols keep their original names
- Only handle edge cases (cross-module shadowing, CJS params) in
lightweight `register_nested_scope_symbols()`

**2. Skip storing original-named nested symbols**
- Add `canonical_name_for_or_original()` method that falls back to
original name
- Only store symbols in `canonical_names` when actually renamed
- Reduces HashMap insertions for ~80-90% of nested symbols

**3. Fix duplicate declaration bug**
- When renaming nested symbols (e.g., `a` → `a$1`), check if the
candidate name already exists in the same module
- Prevents generating invalid code like `function test(a$1, a$1)` when
both `a` and `a$1` exist as parameters

### How It Works

**Old algorithm:**
1. Rename all root scope symbols
2. Iterate through ALL nested scope symbols to check for conflicts
3. Rename nested symbols that conflict with renamed root symbols

**New algorithm:**
1. During root scope renaming, pick names that don't conflict with
nested scopes upfront
2. Most nested scope symbols keep original names (no storage needed)
3. Only rename nested symbols that shadow cross-module or renamed
top-level symbols
4. Check for duplicate declarations when generating renamed names

```text
 ┌─────────────────────────────────────────────────────────────────┐
 │ Phase 1: Root Scope Renaming                                    │
 ├─────────────────────────────────────────────────────────────────┤
 │  for each top-level symbol:                                     │
 │    → Check: used_canonical_names (top-level conflicts)          │
 │    → Check: entry module nested scopes (avoid capture)          │
 │    → Check: own module nested scopes (avoid capture)            │
 │    → Pick name that avoids ALL conflicts upfront                │
 └─────────────────────────────────────────────────────────────────┘
                               ↓
 ┌─────────────────────────────────────────────────────────────────┐
 │ Phase 2: Nested Scope Renaming (lightweight)                    │
 ├─────────────────────────────────────────────────────────────────┤
 │  for each nested symbol:                                        │
 │    ├─ shadows cross-module top-level? ──→ rename                │
 │    ├─ shadows renamed top-level?      ──→ rename                │
 │    ├─ is CJS `exports`/`module`?      ──→ rename                │
 │    └─ otherwise ──→ keep original (no storage needed)           │
 │                                                                 │
 │  When renaming, check candidate doesn't exist in same module    │
 │  to prevent duplicate declarations:                             │
 │                                                                 │
 │    Input: function test(a, a$1) { ... }                         │
 │           where `a` shadows top-level from another module       │
 │                                                                 │
 │    Rename `a`:                                                  │
 │      try `a$1` → exists in module scope → skip                  │
 │      try `a$2` → available → use it ✓                           │
 │                                                                 │
 │    Result: function test(a$2, a$1) { ... }                      │
 └─────────────────────────────────────────────────────────────────┘
```

### Test Case

Added `nested_scope_rename_counter` test to verify the duplicate
declaration fix:

```js
// other.js
export const a = 'from-other';

// module_with_nested.js - has both `a` and `a$1` as parameters
export function test(a, a$1) { return [a, a$1]; }

// main.js
import { a } from './other.js';
import { test } from './module_with_nested.js';
```
**Before fix**: `function test(a$1, a$1)` - duplicate declarations!

**After fix**: `function test(a$2, a$1)` - correctly skips `a$1` since
it already exists

### Snapshot Changes
The optimization produces slightly different (but equally correct)
variable names:

- Avoids ugly `$1$1` double-suffix patterns
- Names are chosen to avoid nested scope conflicts upfront

---------

Co-authored-by: Claude Opus 4.5 <[email protected]>
Co-authored-by: Yunfei He <[email protected]>