feat(extensions): implement gh-style extension system for gpd

Add a complete extension system that allows third-party developers to
ship installable subcommands for gpd, similar to GitHub CLI's extension
mechanism.

Features:
- Extension install from GitHub repos (owner/repo format)
- Local path installation for development
- GitHub Release artifact download with platform detection
- Git clone fallback for script extensions
- Pinned extension support (--pin flag)
- Extension list, remove, upgrade commands
- Direct extension execution (gpd <extension-name>)
- Built-in command conflict detection
- Full test coverage (50+ tests)

Commands added:
- gpd extension install <source>
- gpd extension list [--output json|table]
- gpd extension remove <name>
- gpd extension upgrade [<name>|--all]
- gpd extension exec <name> [args...]

Files added:
- internal/extensions/*.go - Core extension management
- internal/cli/kong_extensions.go - CLI commands
- internal/cli/extension_runner*.go - Platform-specific execution
- *_test.go - Comprehensive test coverage

Refs: gh-style extension system

Author: dl-alexandre

internal/cli/extension_runner.go

@@ -0,0 +1,116 @@
+package cli
+
+import (
+	"os"
+	"os/exec"
+
+	"github.com/dl-alexandre/Google-Play-Developer-CLI/internal/extensions"
+	"github.com/dl-alexandre/Google-Play-Developer-CLI/internal/logging"
+)
+
+// tryRunExtension attempts to execute an extension if the command is an extension name.
+// Returns true if an extension was found and executed, false otherwise.
+func tryRunExtension(args []string) bool {
+	if len(args) == 0 {
+		return false
+	}
+
+	cmdName := args[0]
+
+	// Skip if it's a known global flag or built-in command
+	if isGlobalFlag(cmdName) || extensions.IsBuiltInCommand(cmdName) {
+		return false
+	}
+
+	// Check if this is an installed extension
+	if !extensions.IsInstalled(cmdName) {
+		return false
+	}
+
+	// Get the extension executable path
+	execPath, err := extensions.GetExecutablePath(cmdName)
+	if err != nil {
+		logging.Debug("Failed to get extension executable path",
+			logging.String("extension", cmdName),
+			logging.String("error", err.Error()),
+		)
+		return false
+	}
+
+	// Verify the executable exists
+	if _, err := os.Stat(execPath); os.IsNotExist(err) {
+		logging.Debug("Extension executable not found",
+			logging.String("extension", cmdName),
+			logging.String("path", execPath),
+		)
+		return false
+	}
+
+	// Execute the extension with remaining arguments
+	// Use syscall.Exec on Unix systems for proper signal handling
+	// Fall back to os/exec on Windows
+	extArgs := args[1:]
+
+	logging.Debug("Executing extension",
+		logging.String("extension", cmdName),
+		logging.String("executable", execPath),
+		logging.Int("arg_count", len(extArgs)),
+	)
+
+	// Try execve on Unix for proper signal handling
+	if syscallExecAvailable() {
+		err := execExtension(execPath, extArgs)
+		if err != nil {
+			logging.Debug("syscall.Exec failed, falling back to os/exec",
+				logging.String("error", err.Error()),
+			)
+			// Fall through to os/exec
+		}
+	}
+
+	// Use os/exec for Windows or as fallback
+	cmd := exec.Command(execPath, extArgs...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			// Propagate the exit code
+			if exitErr.ExitCode() != 0 {
+				os.Exit(exitErr.ExitCode())
+			}
+		} else {
+			logging.Debug("Extension execution failed",
+				logging.String("extension", cmdName),
+				logging.String("error", err.Error()),
+			)
+			os.Exit(1)
+		}
+	}
+
+	os.Exit(0)
+	return true // Should never reach here
+}
+
+// isGlobalFlag checks if the argument is a global flag.
+func isGlobalFlag(arg string) bool {
+	globalFlags := []string{
+		"-h", "--help",
+		"-v", "--version",
+		"--verbose",
+		"--package",
+		"--output",
+		"--pretty",
+		"--timeout",
+		"--key",
+		"--profile",
+	}
+
+	for _, flag := range globalFlags {
+		if arg == flag {
+			return true
+		}
+	}
+	return false
+}

internal/cli/extension_runner_unix.go

@@ -0,0 +1,17 @@
+//go:build !windows
+// +build !windows
+
+package cli
+
+import "syscall"
+
+// syscallExecAvailable returns true on Unix systems where syscall.Exec is available.
+func syscallExecAvailable() bool {
+	// syscall.Exec is always available on Unix systems (Linux, macOS, BSD, etc.)
+	return true
+}
+
+// execExtension executes the extension using syscall.Exec on Unix systems.
+func execExtension(execPath string, args []string) error {
+	return syscall.Exec(execPath, append([]string{execPath}, args...), syscall.Environ())
+}

internal/cli/extension_runner_windows.go

@@ -0,0 +1,19 @@
+//go:build windows
+// +build windows
+
+package cli
+
+// syscallExecAvailable returns false on Windows since syscall.Exec is not available.
+func syscallExecAvailable() bool {
+	// Windows does not support syscall.Exec
+	// We always use os/exec.Command on Windows
+	return false
+}
+
+// execExtension is a no-op on Windows since we always use os/exec.
+// This function exists for API compatibility but should never be called on Windows.
+func execExtension(execPath string, args []string) error {
+	// On Windows, we use exec.Command instead
+	// This function should not be called on Windows
+	panic("execExtension should not be called on Windows - use exec.Command instead")
+}