Replace azure-diagnostics skill Function App telemetry discovery chain with a script

## Summary

Copilot has identified a portion of a skill that is a good candidate for replacement with a script.

The candidate is the **Function App → Application Insights / Log Analytics discovery + log-flow confirmation chain** in the `azure-diagnostics` skill (`plugin/skills/azure-diagnostics/references/functions/README.md`).

## Candidate description

To diagnose a Function App, the skill discovers the linked telemetry resources and confirms logs are flowing via a deterministic get-then-use pipeline:

1. **Preferred path** — a single Azure Resource Graph query to find the App Insights component + Log Analytics workspace linked to the function app.
2. **CLI fallback (explicit output chaining):**
- **Step 1:** `az functionapp config appsettings list` → extract `APPINSIGHTS_INSTRUMENTATIONKEY` / connection string
- **Step 2:** `az monitor app-insights component show ... --query "[?instrumentationKey=='']"` → get the component + its `workspaceResourceId`
- **Step 3:** resolve the Log Analytics workspace from that `workspaceResourceId`
3. **Confirm logs are flowing** — run an App Insights `traces` probe query and report a clear "logs are/aren't flowing" verdict.

This is a strong script candidate because it is:
- **A deterministic get-then-use pipeline** — each step's output is the next step's input (instrumentation key → component → workspace), exactly the kind of chaining a script does reliably.
- **Output-heavy** — `appsettings list` and `component show` return large objects where only a few fields matter (App Insights name, connection string, workspace GUID).
- **Self-contained fallback logic** — "try the single ARG query, else run the 3-step CLI chain" is mechanical and well-defined.

**Sketch — `find-functionapp-telemetry.{sh,ps1}`:**
- **Input:** `--name`, `--resource-group` (optional `--subscription`).
- **Output:** the resolved App Insights name/connection string + Log Analytics workspace ID, plus a "logs flowing: yes/no" verdict from the trace probe — so the agent skips re-parsing appsettings/component JSON.

> The classic-vs-workspace-based App Insights branch (workspaceId null → use `traces`/`requests` vs `FunctionAppLogs`) is rule-based and can be encoded; interpreting *why* logs are empty stays in prose.

## Affected file and lines

- [`references/functions/README.md` — ARG discovery, CLI fallback (Steps 1–3), and log-flow confirmation (L9–L64)](https://github.com/microsoft/GitHub-Copilot-for-Azure/blob/3890cbfb65c548ce8daa96cabd1d8de63f7bbcca/plugin/skills/azure-diagnostics/references/functions/README.md#L9-L64)

## Next steps

1. **Evaluate the candidate** — confirm the steps are stable and parameterizable, and that the script captures everything the skill needs.
2. **Create both a bash _and_ a PowerShell version** of the script so the skill works across platforms.
3. **Run integration tests** to verify the scripts behave correctly and the skill still completes end-to-end.

## Background Information

### Why replace regular steps with scripts

Replacing a regular, well-defined series of steps with a script can:

- **Reduce token usage** — the skill no longer needs to spell out each command and parse large command output inline; the agent invokes one script and reads a compact result.
- **Improve reliability** — the logic is written and tested once, instead of being re-derived by the agent on every run.
- **Improve determinism** — the same inputs always produce the same steps and output, removing run-to-run variation.
- **Improve speed of execution** — a single script call replaces multiple round-trips of command generation, execution, and large-output parsing.

### Authoring notes for the scripts

- **Reference scripts with markdown links**, not just a bare path to the script file.
- **Include examples** in the skill showing how to run each script (sample invocation with arguments).
- **Briefly explain what each script does** where it is referenced.
- **The script output should explain what it did**, so the agent and user can understand the result without re-inspecting raw command output.