Phase L: emit discriminated unions in Python codegen + drop hand-written PermissionRequestResult

Brings Python in line with TS/Rust/.NET/Go which all emit per-variant types
for �nyOf-of-\ discriminated unions in the schemas (PermissionRequest,
PermissionDecision, AuthInfo, SendAttachment, ToolExecutionCompleteContent,
TaskInfo, SystemNotification, etc.). Previously the Python codegen merged
each one into a single flat dataclass with every variant's fields collapsed
to Optional — see `scripts/codegen/python.ts:897-901` for the old remap
table that fronted the merged blob as `PermissionRequest`.

Codegen changes (`scripts/codegen/python.ts`)

* `tryEmitPyRefBasedDiscriminatedUnion` in the hand-written session-events
  pipeline emits each variant as its own `@dataclass`, plus a
  `Name = VariantA | VariantB | ...` union alias and a `_load_Name(obj)`
  dispatcher that switches on the discriminator (matches `findPyDiscriminator`).
* `postProcessRefBasedDiscriminatedUnionsForPython` does the equivalent on
  the quicktype-emitted RPC types: detects each `\`-based discriminated
  union, deletes the merged flat class quicktype produced, emits the union
  alias and dispatcher, and rewrites every `Name.from_dict(x)` / `to_class(Name, x)`
  call (including in RPC method wrappers generated later) to route through
  the dispatcher.
* Acronym resolution table (`Api → API`, `Mcp → MCP`, `Cli → CLI`, etc.)
  to map schema names to the actual class names quicktype emits.
* `postProcessDiscriminatorDefaultsForPython` replaces the dataclass-level
  `kind` field on each variant with a class-level `ClassVar[str]` constant.
  Users construct variants with no discriminator arg required:
  `PermissionDecisionApproveOnce()` instead of
  `PermissionDecisionApproveOnce(kind=PermissionDecisionApproveOnceKind.APPROVE_ONCE)`.
  `from_dict` / `to_dict` are rewritten in lock-step.

Hand-written SDK changes

* `copilot.session.PermissionRequestResult` becomes a type alias for
  `PermissionDecision | PermissionNoResult` (mirrors TS
  `nodejs/src/types.ts:883`). The hand-written `PermissionRequestResult`
  dataclass and the `_decision_from_result` mapper are gone — handlers now
  return the generated variant directly. `PermissionNoResult` is a tiny
  hand-written sentinel for the v1-protocol case.
* `PermissionHandler.approve_all` returns `PermissionDecisionApproveOnce()`.
* `CopilotSession._execute_permission_and_respond` passes the returned
  decision straight through to the RPC; v2 servers reject `PermissionNoResult`
  with a clear `ValueError`.
* `CopilotClient._handle_permission_request_v2` uses `_load_PermissionRequest`
  and serialises the variant result with `.to_dict()`.

Tests and scenarios updated in lock-step.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: SteveSandersonMS

python/copilot/client.py

@@ -39,15 +39,16 @@
 from .generated.rpc import (
     ClientSessionApiHandlers,
     ConnectRequest,
+    PermissionDecisionUserNotAvailable,
     RemoteSessionMode,
     ServerRpc,
     _InternalServerRpc,
     from_datetime,
     register_client_session_api_handlers,
 )
 from .generated.session_events import (
-    PermissionRequest,
     SessionEvent,
+    _load_PermissionRequest,
     session_event_from_dict,
 )
 from .session import (
@@ -61,6 +62,7 @@
     ExitPlanModeHandler,
     InfiniteSessionConfig,
     MCPServerConfig,
+    PermissionNoResult,
     ProviderConfig,
     ReasoningEffort,
     SectionTransformFn,
@@ -3193,22 +3195,14 @@ async def _handle_permission_request_v2(self, params: dict) -> dict:
             raise ValueError(f"unknown session {session_id}")
 
         try:
-            perm_request = PermissionRequest.from_dict(permission_request)
+            perm_request = _load_PermissionRequest(permission_request)
             result = await session._handle_permission_request(perm_request)
-            if result.kind == "no-result":
+            if isinstance(result, PermissionNoResult):
                 raise ValueError(NO_RESULT_PERMISSION_V2_ERROR)
-            return {"result": {"kind": result.kind}}
+            return {"result": result.to_dict()}
         except ValueError as exc:
             if str(exc) == NO_RESULT_PERMISSION_V2_ERROR:
                 raise
-            return {
-                "result": {
-                    "kind": "user-not-available",
-                }
-            }
+            return {"result": PermissionDecisionUserNotAvailable().to_dict()}
         except Exception:  # pylint: disable=broad-except
-            return {
-                "result": {
-                    "kind": "user-not-available",
-                }
-            }
+            return {"result": PermissionDecisionUserNotAvailable().to_dict()}