ci(session-e2e): use zig cc directly as cgo compiler, matching goreleaser

Drop the single-binary zig launcher wrappers in favor of goreleaser's
direct CC=zig cc -target x86_64-windows-gnu / CXX=zig c++ ... and carry
over CGO_CXXFLAGS=-fno-sanitize=all, so the Windows e2e build uses the
same toolchain config as the release cross-build.

Author: u9g

.github/workflows/session-e2e.yaml

@@ -74,53 +74,15 @@ jobs:
           go-version-file: go.mod
           cache: true
 
-      # Wrap `zig cc`/`zig c++` in single-binary launchers and point CC/CXX at
-      # them. Why not CC="zig cc -target ..." directly: the cgo build links ~560
-      # object files (webrtc APM + portaudio), whose paths overflow Windows'
-      # ~32KB command-line limit ("fork/exec zig.exe: The filename or extension
-      # is too long"). Go's linker avoids this by writing the args to a @response
-      # file, but only after probing that the linker accepts one -- and the probe
-      # runs only argv[0] of $CC. With a multi-token CC that's bare `zig` (no
-      # `cc` subcommand), so the probe fails, Go skips the response file, and the
-      # full argv overflows. A single-binary CC makes the probe pass. Must run
-      # after Set up Go (it builds the launchers) and before any cgo build.
-      - name: Build zig cgo launchers (Windows)
+      # Use `zig cc`/`zig c++` directly as the cgo toolchain, exactly as
+      # .goreleaser.yaml's Windows builds do. Go's cgo splits a multi-token
+      # CC/CXX into argv, so the `-target` flags are carried through to zig.
+      - name: Set zig as cgo compiler (Windows)
         if: matrix.os == 'windows-latest'
         shell: bash
         run: |
-          dir="$(cygpath "$RUNNER_TEMP")/zigcc"
-          mkdir -p "$dir"
-          cat > "$dir/main.go" <<'EOF'
-          // Forwards to `zig cc`/`zig c++ -target x86_64-windows-gnu`, picking the
-          // subcommand from its own basename, so $CC/$CXX are single executables.
-          package main
-
-          import (
-          	"os"
-          	"os/exec"
-          	"path/filepath"
-          	"strings"
-          )
-
-          func main() {
-          	sub := "cc"
-          	if b := filepath.Base(os.Args[0]); strings.Contains(b, "xx") || strings.Contains(b, "++") {
-          		sub = "c++"
-          	}
-          	cmd := exec.Command("zig", append([]string{sub, "-target", "x86_64-windows-gnu"}, os.Args[1:]...)...)
-          	cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
-          	if err := cmd.Run(); err != nil {
-          		if ee, ok := err.(*exec.ExitError); ok {
-          			os.Exit(ee.ExitCode())
-          		}
-          		os.Exit(1)
-          	}
-          }
-          EOF
-          (cd "$dir" && go mod init zigcc && go build -o zcc.exe . && go build -o zxx.exe .)
-          win="$(cygpath -w "$dir")"
-          echo "CC=$win\\zcc.exe" >> "$GITHUB_ENV"
-          echo "CXX=$win\\zxx.exe" >> "$GITHUB_ENV"
+          echo 'CC=zig cc -target x86_64-windows-gnu' >> "$GITHUB_ENV"
+          echo 'CXX=zig c++ -target x86_64-windows-gnu' >> "$GITHUB_ENV"
 
       # Go's compiled objects embed COFF /DEFAULTLIB directives (dbghelp,
       # bcrypt, ...) that lld resolves directly, bypassing zig's lazy .def->.a
@@ -161,6 +123,9 @@ jobs:
           # Go's cgo flag allowlist rejects it unless explicitly permitted (same
           # as .goreleaser.yaml's Windows builds). No-op on Linux/macOS.
           CGO_CXXFLAGS_ALLOW: -fms-extensions
+          # zig-0.16 UBSan workaround carried over from .goreleaser.yaml's
+          # Windows builds; empty (no-op) on Linux/macOS.
+          CGO_CXXFLAGS: ${{ matrix.os == 'windows-latest' && '-fno-sanitize=all' || '' }}
           LIVEKIT_API_KEY: ${{ secrets.LIVEKIT_API_KEY }}
           LIVEKIT_API_SECRET: ${{ secrets.LIVEKIT_API_SECRET }}
           LIVEKIT_URL: ${{ secrets.LIVEKIT_URL }}