avoid call to loadSharedCache for toolexec calls we skip

We were doing too much work for tools we don't need to wrap at all,
such as `go tool pack` or `go tool buildid`, which get run about as
often as the compiler does.

The overhead is small per call, but it adds up.

	name      old time/op         new time/op         delta
	Build-16          20.7s ± 0%          20.5s ± 1%    ~     (p=0.057 n=4+4)

	name      old bin-B           new bin-B           delta
	Build-16          5.67M ± 0%          5.66M ± 0%  -0.07%  (p=0.029 n=4+4)

	name      old cached-time/op  new cached-time/op  delta
	Build-16          707ms ± 0%          705ms ± 2%    ~     (p=0.886 n=4+4)

	name      old mallocs/op      new mallocs/op      delta
	Build-16          25.0M ± 0%          24.9M ± 0%  -0.26%  (p=0.029 n=4+4)

	name      old sys-time/op     new sys-time/op     delta
	Build-16          8.32s ± 2%          7.90s ± 3%  -5.05%  (p=0.029 n=4+4)

main.go

@@ -403,16 +403,22 @@ func mainErr(args []string) error {
 		return cmd.Run()
 
 	case "toolexec":
+		_, tool := filepath.Split(args[0])
+		if runtime.GOOS == "windows" {
+			tool = strings.TrimSuffix(tool, ".exe")
+		}
+		transform := transformFuncs[tool]
+		transformed := args[1:]
+		if transform != nil {
+			startTime := time.Now()
+			log.Printf("transforming %s with args: %s", tool, strings.Join(transformed, " "))
+
 			// We're in a toolexec sub-process, not directly called by the user.
 			// Load the shared data and wrap the tool, like the compiler or linker.
 			if err := loadSharedCache(); err != nil {
 				return err
 			}
 
-		_, tool := filepath.Split(args[0])
-		if runtime.GOOS == "windows" {
-			tool = strings.TrimSuffix(tool, ".exe")
-		}
 			if len(args) == 2 && args[1] == "-V=full" {
 				return alterToolVersion(tool, args)
 			}
@@ -423,11 +429,6 @@ func mainErr(args []string) error {
 				return fmt.Errorf("TOOLEXEC_IMPORTPATH not found in listed packages: %s", toolexecImportPath)
 			}
 
-		transform := transformFuncs[tool]
-		transformed := args[1:]
-		if transform != nil {
-			startTime := time.Now()
-			log.Printf("transforming %s with args: %s", tool, strings.Join(transformed, " "))
 			var err error
 			if transformed, err = transform(transformed); err != nil {
 				return err