chore: bump @github/copilot to ^1.0.75 and regenerate all SDKs

Moves the runtime dependency from ^1.0.73 to ^1.0.75 and regenerates the
wire types for every language. No hand-written API changes beyond what the
new schemas force.

Generated surface
- Regenerates rpc/session-event types for Node.js, Python, Go, .NET, and
  Rust from the 1.0.75 schemas.

Codegen: narrow the opaque-JSON conversion
- `x-opaque-json` was being applied to every annotated definition, but only
  one of the fourteen (`CanvasJsonSchema`) is genuinely unconstrained; the
  rest carry `anyOf` or `type` + `properties`. Blanket-converting them threw
  away the structure of `McpServerConfig`, `ExternalToolResult`,
  `EventLogTypes`, and `UIElicitationSchemaProperty`. The conversion now
  requires the absence of any structural keyword.
- Genuinely opaque nodes emit `JsonValue` instead of `unknown`, which is a
  global tightening; `ToolTelemetry` is realigned to match.

Fallout the new schemas force
- `sessionFs` gained `sqliteTransaction`, so every hand-written provider
  adapter has to implement it. Node forwards to an optional provider hook
  and classifies failures; Python, Go, and .NET have no transaction hook in
  their provider interfaces, so they refuse the batch with a classified
  `fatal` error rather than applying it non-atomically.
- `UIExitPlanModeResponse` gained `deferImplementation`, so the Rust e2e
  struct literal has to name it.
- `lsp.initialize` and `telemetry.setFeatureOverrides` are declared
  `Promise<void>` and now resolve with `{}` rather than `null`, so two e2e
  assertions no longer pin the resolved value.
- The `JsonValue` tightening reaches `data.arguments`, which is no longer
  optional-chained in the session-event type test.

Author: MRayermannMSFT

dotnet/src/Generated/Rpc.cs

@@ -309,6 +309,24 @@ async Task<SessionFsSqliteQueryResult> ISessionFsHandler.SqliteQueryAsync(Sessio
         }
     }
 
+    Task<SessionFsSqliteTransactionResult> ISessionFsHandler.SqliteTransactionAsync(SessionFsSqliteTransactionRequest request, CancellationToken cancellationToken)
+    {
+        // This SDK's provider interface exposes no atomic-transaction hook, so
+        // the batch is refused outright rather than applied non-atomically.
+        var message = this is ISessionFsSqliteProvider
+            ? "Atomic SQLite transactions are not supported by this SessionFs provider"
+            : "SQLite is not supported by this SessionFs provider";
+
+        return Task.FromResult(new SessionFsSqliteTransactionResult
+        {
+            Error = new SessionFsSqliteTransactionError
+            {
+                ErrorClass = SessionFsSqliteTransactionErrorClass.Fatal,
+                Message = message,
+            },
+        });
+    }
+
     async Task<SessionFsSqliteExistsResult> ISessionFsHandler.SqliteExistsAsync(SessionFsSqliteExistsRequest request, CancellationToken cancellationToken)
     {
         if (this is not ISessionFsSqliteProvider sqliteProvider)