[dotnet-ai] Agent stack (agentic-workflow + copilot-sdk-integration)

## Parent Issue

Part of the `dotnet-ai` plugin proposal: #225

## Summary

Add the `agentic-workflow` and `copilot-sdk-integration` skills to the `dotnet-ai` plugin.

These two skills are tightly coupled — they represent adjacent layers of the .NET agent stack (Runtime vs Harness) and include a **Bridge Pattern** that shows how to prototype with Copilot SDK and deploy with MAF + Azure OpenAI. Their cross-references are integral, so they are submitted together.

## The .NET Agent Stack

```
┌──────────────┬───────────────────────────────────────┐
│ Harness │ GitHub Copilot SDK (CopilotClient) │ copilot-sdk-integration
├──────────────┼───────────────────────────────────────┤
│ Runtime │ Microsoft Agent Framework (AIAgent) │ agentic-workflow
├──────────────┼───────────────────────────────────────┤
│ Framework │ Microsoft.Extensions.AI (IChatClient) │ meai-chat-integration
└──────────────┴───────────────────────────────────────┘
```

The Bridge Pattern connects these layers: `CopilotClient.AsAIAgent()` produces a MAF `AIAgent` backed by Copilot. In production, swap to `azureClient.AsAIAgent()` — same agent code, different backend.

## Skills in This Issue

### agentic-workflow

Guides developers through building multi-step agent applications using Microsoft Agent Framework (MAF).

**Covers:**
- **AIAgent creation** via `chatClient.AsAIAgent()` — the `ChatClientAgent` pattern
- **Tool definition** with `[Description]` attributes and `AIFunctionFactory.Create()`
- **AgentSession** for multi-turn conversation state management
- **Multi-agent composition** via `AsAIFunction()` — expose agents as tools for a supervisor
- **Durable agents** for production (Azure Functions + Durable Task, external storage, horizontal scaling, human-in-the-loop)
- **A2A protocol** via `MapA2A()` for remote agent-to-agent communication
- **Guardrails** — timeouts, token limits, tool count per agent
- **Observability** — log role and tool name only, never message content (PII risk)
- **Provider flexibility** — works with any IChatClient (OpenAI, Azure OpenAI, Ollama, CopilotClient)

**Does NOT cover:**
- Simple prompt/response LLM calls (use `meai-chat-integration`)
- Building Copilot platform extensions (use `copilot-sdk-integration`)

### copilot-sdk-integration

Guides developers through using the GitHub Copilot SDK with three distinct paths.

**Path A — CopilotClient as LLM Backend:**
- Zero-config auth via `gh` CLI (no API keys)
- SessionConfig and model selection
- MAF integration via `CopilotClient.AsAIAgent()` (bridge package)
- BYOK (Bring Your Own Key) for OpenAI, Azure OpenAI, Anthropic, Ollama

**Path B — Agent Harness Features:**
- Session persistence (`~/.copilot/session-state/`)
- MCP server integration
- Infinite-session context compaction
- Safe outputs for CI/CD

**Path C — Platform Extensions:**
- ASP.NET Core hosting for Copilot agents
- Tool registration with the Copilot runtime
- GitHub App authentication
- Testing with `gh copilot` CLI

**Bridge Pattern:**
- Prototype with CopilotClient (zero-config) → deploy with Azure.AI.OpenAI (Entra ID, horizontal scaling)
- Same AIAgent abstraction — agent code unchanged across backends

**Limitations section:**
- Technical Preview status
- CLI binary dependency (50-80MB external process)
- BYOK: static credentials only (no Entra ID, no managed identity)
- Local filesystem session state (no horizontal scaling)
- No .NET WASM transport
- Opaque agent runtime inside CLI binary

## Files

```
plugins/dotnet-ai/skills/agentic-workflow/SKILL.md
plugins/dotnet-ai/skills/copilot-sdk-integration/SKILL.md
tests/dotnet-ai/agentic-workflow/eval.yaml
tests/dotnet-ai/copilot-sdk-integration/eval.yaml
```

## Eval Scenarios

**agentic-workflow:**
1. **Build agent with tool calling using MAF** — expects AIAgent via AsAIAgent(), AgentSession, UseFunctionInvocation()
2. **Multi-agent orchestration with AsAIFunction** — expects supervisor pattern with specialist agents as tools
3. **Recommend durable agents for production** — expects MAF durable agents for persistence/scaling, NOT Copilot SDK

**copilot-sdk-integration:**
1. **Use CopilotClient as LLM backend** — expects CopilotClient with zero-config auth
2. **Build a Copilot platform extension** — expects ASP.NET Core hosting with GitHub App auth
3. **Redirect to MAF for enterprise production** — expects redirect when Entra ID or horizontal scaling needed
4. **BYOK with Azure OpenAI** — expects ProviderConfig with type azure

## Key Packages

- `Microsoft.Extensions.AI` (foundation)
- `Microsoft.Agents.AI` (MAF — prerelease)
- `GitHub.Copilot.SDK` (Copilot SDK — prerelease)
- `Microsoft.Agents.AI.GitHub.Copilot` (bridge — prerelease)

## Dependencies

Requires the plugin scaffold (sub-issue #1) to be merged first. Ideally `meai-chat-integration` is merged first since both skills reference IChatClient as the foundation.

## Acceptance Criteria

- [ ] agentic-workflow centers on MAF AIAgent patterns (not just IChatClient function calling)
- [ ] AsAIAgent(), AgentSession, AsAIFunction() are all covered with code examples
- [ ] Durable agents and A2A protocol are documented for production scenarios
- [ ] copilot-sdk-integration covers all three dimensions (LLM backend, harness, platform extension)
- [ ] Bridge Pattern is documented with side-by-side code showing Copilot vs Azure OpenAI backends
- [ ] Limitations section is present and accurate
- [ ] eval.yaml files cover positive scenarios and redirect scenarios