## Current Behavior

In `filterAffectedProjects`, a **new visited Set is created for each
touched project**:

```typescript
ctx.touchedProjects.forEach((p) => {
  addAffectedNodes(p, reversed, result, new Set());  // NEW Set per project!
});
ctx.touchedProjects.forEach((p) => {
  addAffectedDependencies(p, reversed, result, new Set());  // NEW Set per project!
});
```

This defeats the purpose of the visited Set for deduplication. If
projects A and B both depend on shared project C, then C gets visited
**twice**.

## Expected Behavior

Share a single visited Set across all touched projects:

```typescript
const visitedNodes = new Set<string>();
const visitedDeps = new Set<string>();
for (const p of ctx.touchedProjects) {
  addAffectedNodes(p, reversed, result, visitedNodes);  // SHARED Set
}
for (const p of ctx.touchedProjects) {
  addAffectedDependencies(p, reversed, result, visitedDeps);  // SHARED Set
}
```

## Performance Impact

```
Before (separate Sets):              After (shared Sets):
┌─────────────────────────┐         ┌─────────────────────────┐
│  touchedProjects: [A,B] │         │  touchedProjects: [A,B] │
└───────────┬─────────────┘         └───────────┬─────────────┘
            │                                   │
    ┌───────┴───────┐                   ┌───────┴───────┐
    ▼               ▼                   ▼               ▼
┌───────┐       ┌───────┐           ┌───────┐       ┌───────┐
│ A     │       │ B     │           │ A     │       │ B     │
│visited│       │visited│           │       │       │       │
│= {}   │       │= {}   │           │ shared visitedNodes   │
└───┬───┘       └───┬───┘           └───┬───┘       └───┬───┘
    │               │                   │               │
    ▼               ▼                   ▼               ▼
┌───────┐       ┌───────┐           ┌───────────────────────┐
│visit C│       │visit C│           │ visit C (ONCE)        │
│(dup!) │       │(dup!) │           │ skip C from B         │
└───────┘       └───────┘           └───────────────────────┘

Complexity:                         Complexity:
O(touched × shared_deps)            O(total_nodes)
```

**Example**: With 50 touched projects sharing 100 common dependencies:
- Before: 50 × 100 = 5,000 node visits
- After: ~150 node visits (each node visited once)

## Why Accept This PR

1. **Bug-like behavior**: The current code defeats the purpose of the
visited Set
2. **Significant impact**: Affects every `nx affected` command
3. **Zero risk**: Same traversal logic, just shared deduplication
4. **Common scenario**: Monorepos often have shared dependencies (utils,
types, etc.)
## Related Issue(s)

Contributes to #32265

## Merge Dependencies

This PR has no dependencies and can be merged independently.

---

Co-authored-by: Leosvel Pérez Espinosa <[email protected]>