[EPIC] UX revamp: init, menu, and context

## Problem statement

`azd init` is the first command most developers run in the Azure Developer CLI, and it's a great opportunity to make that first impression even stronger. Template selection currently uses a flat list, and we're adding context-aware intelligence so developers find the right template faster. We're also integrating the agentic `init` flow (where AI helps scaffold a project) into the main path, enabling extensions to participate in `init`, and adding collision detection for existing projects.

As `azd` grows with new capabilities like AI agents, extensions, and `azd tool`, we're investing in published UX guidelines to ensure every command feels consistent and discoverable, whether built by the core team or the extension community.

## Vision

`azd init` becomes the smartest command in the CLI: it understands what's already in your directory, recommends the right template, detects collisions, and lets extensions participate in the scaffolding process. The broader `azd` UX follows published guidelines that ensure every command, whether built by the core team or an extension developer, feels consistent, discoverable, and delightful. Agentic flows are a primary UX pattern, not a bolted-on experiment.

## Who this helps

- **Developers new to Azure**: Run `azd init` in a project directory and get an intelligent experience: `azd` detects existing code, suggests relevant templates, flags potential conflicts, and offers AI-assisted scaffolding. No scrolling through a long template list to find the right one.
- **Experienced Azure developers**: Benefit from a faster, smarter `init` that respects existing project structure. Use agentic `init` to quickly scaffold new AI features into existing applications.
- **Extension developers**: Follow published UX guidelines to build extensions that feel native to `azd`. Register extension init flows so developers discover them naturally during `azd init`.
- **CI/automation users**: Unaffected: non-interactive paths remain stable and backward-compatible.

## Goals (in scope)

- **Redesign `azd init`**: Smarter template selection (context-aware, not just a flat list), agentic init integration, collision detection for existing projects
- **Publish UX guidelines**: Documented patterns for hints, menus, agentic flows, progressive disclosure, and extension UX. These become the contract for how `azd` commands should look and behave.
- **Extension participation in init**: Extensions can register init flows so their scaffolding appears during `azd init` (e.g., a Foundry extension adding agent project scaffolding)
- **Context awareness**: `azd init` should understand what's already in the directory (existing code, config files, frameworks) and adapt its behavior accordingly

## Non-goals (out of scope)

- Changing the `azd` command structure or breaking existing CLI contracts; this is about improving existing commands, not restructuring them
- Redesigning non-interactive/CI paths; backward compatibility for automation is non-negotiable
- Redesigning every `azd` command's UX at once; start with `init` and the guidelines, then apply progressively
- Building a GUI or TUI; this is CLI-native UX improvement

## Success criteria

- [ ] Redesigned `azd init` ships with context-aware template selection
- [ ] Agentic init flow integrated into the main `azd init` path (not a separate hidden command)
- [ ] Collision detection warns developers when initializing into a directory with existing `azd` or conflicting configuration
- [ ] UX guidelines published and accessible to extension developers
- [ ] At least one extension participates in the `init` flow (e.g., Foundry extension or AI extension)
- [ ] Existing non-interactive/CI workflows remain backward-compatible
- [ ] Developer feedback on new `init` experience collected and positive

## Dependencies

- **Extension Framework**: Extension participation in `init` requires the extension framework to support `init` hooks. Depends on extension framework API stability.
- **Agentic flows / AI capabilities**: Agentic `init` integration depends on the existing agentic scaffolding work being stable enough to promote to the main path.
- **Template catalog**: Smarter template selection requires metadata improvements in the template catalog (tags, categories, framework detection).