Run wrapped tools directly as vintner <tool> ..., no PATH needed

`vintner cl ...`, `vintner msbuild ...`, etc. now work without adding
<dest>/bin/<arch> to PATH or relying on the same-directory symlinks
`install` sets up there. wrapper.Run gained an explicit binDir
parameter (empty string preserves the existing os.Executable()-based
self-location for the ordinary multi-call/symlink case) so
cmd/vintner's new runTool can point it at a resolved toolchain
directory instead.

Resolution order: VINTNER_BIN if set (same meaning as `env --bin` -
point it at a <dest>/bin/<arch> directory directly, for a non-default
--dest or a specific architecture), else <defaultToolchainDir>/bin/
<hostArch> - the layout a plain `vintner download && vintner install`
with no --dest override produces. A missing toolchain gets a clear
error pointing at both fixes, rather than bubbling up whatever
wineenv.Load's env.json error looks like.

Also fixed shell completion falling out of sync with the actual tool
list: the bash/zsh scripts previously hand-copied tool/flag names
(and had already gone stale once - --with-dxsdk was missing from the
download flag completions since it was added). The tool name list is
now generated from wrapper.ToolNames() instead of hand-maintained,
and both scripts now complete tool names too, so `vintner <TAB>`
suggests `cl`, `link`, `msbuild`, etc. alongside the management
subcommands.

Verified end-to-end with a minimal PATH (/usr/bin:/bin only, no
toolchain dir on it at all): `vintner cl /nologo hello.c` compiled
successfully, and `vintner msbuild -t:Rebuild ...` rebuilt the same
real KMDF driver verified earlier this session - both via the default
~/.vintner/bin/<hostArch> resolution, no VINTNER_BIN override needed.

internal/wrapper/run.go

@@ -30,7 +30,15 @@ const toolRelayName = "toolrelay.exe"
 
 // Run executes the named multi-call tool with args, exactly as the original
 // bash wrappers would, and returns the process exit code.
-func Run(tool string, args []string) int {
+//
+// binDir is the <dest>/bin/<arch> directory holding env.json for this
+// invocation. Pass "" for the ordinary multi-call case (invoked as `cl`,
+// `link`, etc. via a same-directory symlink) to have it resolved from the
+// running binary's own location; a non-empty value is for `vintner <tool>
+// ...` direct dispatch (see cmd/vintner's runTool), which isn't running
+// from inside any particular <dest>/bin/<arch> and so has nothing to
+// resolve on its own.
+func Run(tool string, args []string, binDir string) int {
 	if nativeTools[tool] {
 		return runNative(tool, args)
 	}
@@ -41,19 +49,23 @@ func Run(tool string, args []string) int {
 		return 127
 	}
 
-	// os.Executable() (backed by /proc/self/exe on Linux) fully resolves
-	// symlinks, unlike os.Args[0]: not every shell passes a PATH-resolved
-	// absolute path as argv[0] (some just pass the bare command name), which
-	// would make an argv[0]-based lookup resolve against the caller's cwd
-	// instead of the actual install dir. `install` sets each arch dir up
-	// with its own local copy of the binary precisely so this resolves to
-	// <dest>/bin/<arch>, not <dest>/bin.
-	exePath, err := os.Executable()
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "vintner:", err)
-		return 1
+	scriptDir := binDir
+	if scriptDir == "" {
+		// os.Executable() (backed by /proc/self/exe on Linux) fully resolves
+		// symlinks, unlike os.Args[0]: not every shell passes a
+		// PATH-resolved absolute path as argv[0] (some just pass the bare
+		// command name), which would make an argv[0]-based lookup resolve
+		// against the caller's cwd instead of the actual install dir.
+		// `install` sets each arch dir up with its own local copy of the
+		// binary precisely so this resolves to <dest>/bin/<arch>, not
+		// <dest>/bin.
+		exePath, err := os.Executable()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "vintner:", err)
+			return 1
+		}
+		scriptDir = filepath.Dir(exePath)
 	}
-	scriptDir := filepath.Dir(exePath)
 
 	cfg, err := wineenv.Load(scriptDir)
 	if err != nil {