Don't generate cargo metadata eagerly in justfile

- Have the `justfile` wait to run `cargo metadata` until it is
  running a recipe that actually needs the information from it.
  (Currently, that information is always the `target` directory
  location, in whose `debug` subdirectory some binaries are found.)

  This avoids a delay if `cargo metadata` has not run. The length
  of the delay varied but was often noticeable on Windows. Because
  running it again (in the absence of a clean or relevant change)
  is cheap, it is not a performance problem that this runs the
  command multiple times instead of once.

  This also avoids error messages from `cargo metadata` if it can't
  complete, unless it is actually being used. Those messages didn't
  prevent other recipes (besides those that used the metadata) from
  running. But they created the appearance of failure, and also
  were misleading when they didn't come from the recipe being run.

- Handle errors from `cargo metadata` more robustly, by causing
  recipes that actually need the result of `cargo metadata` to fail
  if it fail -- and to fail immediately before attempting any other
  operations -- rather than attempting to use empty data.

  The metadata are piped to `jq -r .target_directory`, which
  actually succeeds even if it doesn't receive any data, giving
  empty output. Before, an attempt was made to use the empty output
  in building paths meant to go to debug builds of some binaries.

  Because the command is now running only when the output is
  actually needed, it is fine to make it hard error when it fails.

  The natural way to do this would be to `set -o pipefail`. But
  while it is in the newest POSIX standard, there remain otherwise
  largely POSIX-compatible `sh` implementations in use that don't
  support it (koalaman/shellcheck#2555).

  Our test suite requires `bash`, so the next obvious choice would
  be to use a shebang recipe or script recipe for `bash`. The
  problem is that shebang and script recipes don't usually work on
  Windows, because `just` passes a Windows path with `\` separators
  to the shell unquoted. This often results in the shell trying to
  run a file whose name is transformed by treating them specially,
  then causing them to dropped as if by quote removal. For example,
  on a recipe named `hello` with a `#!/usr/bin/env bash` shebang:

      /bin/bash: C:UsersekAppDataLocalTempjust-BVbCgphello: No such file or directory

  (One way this happens is by argument processing in `cygwin1.dll`
  or `msys-2.0.dll`, which seek to bridge the gap between the Unix
  expectation that the caller is responsible for all expansions and
  the Windows expectation that the callee is responsible for some.
  See rust-lang/rust#82227. Even when
  only globbing is attempted, `\` can be treated specially if it
  seems to escape a wildcard, or to escape another `\` that seems
  to escape a wildcard, etc.)

  Fortunately, in this case we can just check if the result of
  trying to parse out the `target` directory path gave a nonempty
  result, and treat the failure to do that as a hard error.

- Remove the `check-mode` recipe's need for cargo metadata, by
  having it run the `internal-tools` binary via `cargo run` rather
  than looking up where the `target` directory is and finding `it`
  in `debug` under it.

  That approach is needed for the paths that are passed to the
  journey test runner, but `check-mode` can just use `cargo`.

  The preceding build command could be removed, since `cargo run`
  builds unless the binary is up to date. But keeping them as
  separate commands may make the output more readable.

Author: EliahKagan

justfile

@@ -2,8 +2,10 @@
 # ^ A shebang isn't required, but allows a justfile to be executed
 #   like a script, with `./justfile test`, for example.
 
+j := quote(just_executable())
+
 default:
-    {{ quote(just_executable()) }} --list
+    {{ j }} --list
 
 alias t := test
 alias c := check
@@ -191,35 +193,37 @@ unit-tests:
 unit-tests-flaky:
     cargo test -p gix --features async-network-client-async-std
 
-target_dir := `cargo metadata --format-version 1 | jq -r .target_directory`
-ein := quote(target_dir / 'debug/ein')
-gix := quote(target_dir / 'debug/gix')
-jtt := quote(target_dir / 'debug/jtt')
-it := quote(target_dir / 'debug/it')
+# depend on this to pre-generate metadata, and/or use it inside a recipe as `"$({{ j }} dbg)"`
+[private]
+dbg:
+    set -eux; \
+        target_dir="$(cargo metadata --format-version 1 | jq -r .target_directory)"; \
+        test -n "$target_dir"; \
+        echo "$target_dir/debug"
 
 # run journey tests (max)
-journey-tests:
+journey-tests: dbg
     cargo build --features http-client-curl-rustls
     cargo build -p gix-testtools --bin jtt
-    tests/journey.sh {{ ein }} {{ gix }} {{ jtt }} max
+    dbg="$({{ j }} dbg)" && tests/journey.sh "$dbg/ein" "$dbg/gix" "$dbg/jtt" max
 
 # run journey tests (max-pure)
-journey-tests-pure:
+journey-tests-pure: dbg
     cargo build --no-default-features --features max-pure
     cargo build -p gix-testtools --bin jtt
-    tests/journey.sh {{ ein }} {{ gix }} {{ jtt }} max-pure
+    dbg="$({{ j }} dbg)" && tests/journey.sh "$dbg/ein" "$dbg/gix" "$dbg/jtt" max-pure
 
 # run journey tests (small)
-journey-tests-small:
+journey-tests-small: dbg
     cargo build --no-default-features --features small
     cargo build -p gix-testtools
-    tests/journey.sh {{ ein }} {{ gix }} {{ jtt }} small
+    dbg="$({{ j }} dbg)" && tests/journey.sh "$dbg/ein" "$dbg/gix" "$dbg/jtt" small
 
 # run journey tests (lean-async)
-journey-tests-async:
+journey-tests-async: dbg
     cargo build --no-default-features --features lean-async
     cargo build -p gix-testtools
-    tests/journey.sh {{ ein }} {{ gix }} {{ jtt }} async
+    dbg="$({{ j }} dbg)" && tests/journey.sh "$dbg/ein" "$dbg/gix" "$dbg/jtt" async
 
 # Run cargo-diet on all crates to see that they are still in bound
 check-size:
@@ -260,7 +264,7 @@ find-yanked:
 # Find shell scripts whose +x/-x bits and magic bytes (e.g. `#!`) disagree
 check-mode:
     cargo build -p internal-tools
-    {{ it }} check-mode
+    cargo run -p internal-tools -- check-mode
 
 # Delete gix-packetline-blocking/src and regenerate from gix-packetline/src
 copy-packetline: