Feature Proposal: Native Support for Multi-Agent Group Chat (GroupChat / Dialogue Orchestration) API

### Problem Description
Currently, the Google Agent Development Kit (ADK) 2.x provides powerful APIs for single-agent execution (`LlmAgent`/`Agent`) and graph-based execution (`Workflow`/`JoinNode`). However, it lacks a native API for **conversational-based multi-agent group chats (GroupChat / Dialogue Orchestration)**, similar to AutoGen's `GroupChat` and `GroupChatManager`.

When building collaborative applications (like digital employee platforms) where multiple agents need to work in a shared conversation space:
1. **Dialogue-driven collaboration** (e.g., dynamic multi-turn brainstorming, negotiation, or handoffs) is difficult to express cleanly using rigid Directed Acyclic Graphs (`Workflow`).
2. Developers are forced to either:
- Build a custom database-backed state-machine on top of ADK's `Runner` or `LlmAgent` to orchestrate who speaks next and format the message stream (which is how we currently work around it).
- Write complex custom Python async code to manually handle turn-taking, which lacks standard API support.

### Proposed Feature / Behavior
We propose adding native support for a Group Chat / Dialogue Orchestrator API in ADK. This could include:
1. **`GroupChat` Container**: A class that manages a shared conversation history and a collection of participant agents.
2. **`GroupChatManager` (or `DialogueOrchestrator`)**: An agent that decides the next speaker based on:
- Dynamic LLM-based selection (e.g., choosing the next speaker based on chat history).
- Preset transition rules (e.g., a state machine or allowed transition graph).
- Standard routines (e.g., round-robin, random, manual human input).
3. **Structured Event Emission**: Streaming events that include metadata about the active speaker (e.g. `agent_id`, `node_id`) so that frontends can easily route streaming tokens to correct UI elements without interleaving.

### User & Platform Impact
- **Developer Experience**: Significantly reduces boilerplate code when building multi-agent discussion groups, brainstorming channels, or collaborative task-solvers.
- **Flexibility**: Complements ADK's graph-based `Workflow` engine by offering a conversational alternative, allowing developers to choose the right paradigm (structural DAG vs. dynamic dialogue) for the task at hand.
- **Enterprise Readiness**: Makes it easier to build user-friendly UI/UX around multi-agent collaboration (such as enterprise digital employee group chats) with clear speaker attribution and trace streaming.