fix(venv): Don't use dirs as the interpreter (#665)

Fixes #664

On Linux and MacOS, the `current_exe()` path has likely been realpath-ed
by the system or the libc somewhere along the line. This means that if
the user types `.venv/bin/python3`, the entire symlink chain that may
point into will be chased and we'll get a path somewhere inside the
Bazel `execroot/` output tree. Critically on Linux this symlink tree
goes past the `.runfiles/` directory entry the user intended to create a
symlink to, which prevents our interpreter shim from delegating to a
`.runfiles/` packaged Python like the user desired.

In order for us to resolve "just enough" symlinks to identify the
`.runfiles/` tree, we need to manually resolve the path of the current
executable. Previously doing so would create a false positive if there
was a `./python` or `./python3` directory, and the interpreter shim was
invoked as `python3` which is ambiguous as to whether the user meant
`./python3` or `python3 from the $PATH`.

The fix here centers on two insights:
- The "real" interpreter can never be a directory (directly fixes the
bug)
- The "real" interpreter's absolute path _must_ have the _same_ absolute
path as whatever `current_exe()` is

### Changes are visible to end-users: yes

- Searched for relevant documentation and updated as needed: yes
- Breaking change (forces users to change their own code or config): no
- Suggested release notes appear below: yes

Fixed a bug which would cause the interpreter shims to identify
`./python3/` or `./python/` (directories) as the real path of the
interpreter "python3" rather than falling back to `which()` behavior.

### Test plan

- Manual testing

Author: arrdem

py/tools/venv_shim/src/main.rs

@@ -1,8 +1,8 @@
-use miette::IntoDiagnostic;
+use miette::{miette, IntoDiagnostic};
 use runfiles::Runfiles;
 use which::which;
 // Depended on out of rules_rust
-use std::env;
+use std::env::{self, current_exe};
 use std::ffi::OsStr;
 use std::fs;
 use std::os::unix::process::CommandExt;
@@ -245,14 +245,19 @@ fn main() -> miette::Result<()> {
     let cwd = std::env::current_dir().into_diagnostic()?;
     if !executable.is_absolute() {
         let candidate = cwd.join(&executable);
-        if candidate.exists() {
+        if candidate.exists()
+            && !candidate.is_dir()
+            && candidate.canonicalize().unwrap() == current_exe().unwrap().canonicalize().unwrap()
+        {
             executable = candidate;
             #[cfg(feature = "debug")]
             eprintln!("       {:?}", executable);
         } else if let Ok(exe) = which(&exec_name) {
             executable = exe;
             #[cfg(feature = "debug")]
             eprintln!("       {:?}", executable);
+        } else {
+            return Err(miette!("Unable to identify the real interpreter path!"));
         }
     }