Make PathsByRole::maybe_pf_64bit an Option<PathBuf>

The `PathsByRole` test helper struct's `maybe_pf_64bit` member was
previously `Result<PathBuf, std::io::Error>`. But construction,
which is by `PathsByRole::obtain_envlessly()`, already asserted the
expected existence of the other two paths. It should likewise
assert that if the guaranteed-64-bit program files path cannot be
obtained from the registry, then this is due to it being absent,
rather than some other error.

Checking this in `obtain_envlessly()` makes it reasonable for
`maybe_pf_64bit` to be an `Option<PathBuf>`, as its name would
suggest it should be. This in turn makes clear that all the
validation and assertions for this "reference value" have already
been done. Thus `PathsByRole::validate()` can continue omitting
validation for the error type, validation it should not perform
because the point of it is do checks that are agnostic of how the
paths were obtained.

This also makes `PathsByRole` cloneable, which is now possible
because it no longer holds on to a `std::io::Error` with its
non-cloneable dynamic error information, and adds some other
missing traits on test helper types.

Author: EliahKagan

gix-path/src/env/git.rs

@@ -132,6 +132,7 @@ mod tests {
     use {
         known_folders::{get_known_folder_path, KnownFolder},
         std::ffi::{OsStr, OsString},
+        std::io::ErrorKind,
         std::path::PathBuf,
         windows::core::Result as WindowsResult,
         windows::Win32::Foundation::BOOL,
@@ -146,6 +147,7 @@ mod tests {
     }
 
     #[cfg(windows)]
+    #[derive(Clone, Copy, Debug)]
     enum PlatformArchitecture {
         Is32on32,
         Is32on64,
@@ -180,6 +182,7 @@ mod tests {
     }
 
     #[cfg(windows)]
+    #[derive(Clone, Debug)]
     struct PathsByRole {
         /// The program files directory relative to what architecture this program was built for.
         pf_current: PathBuf,
@@ -194,7 +197,7 @@ mod tests {
         /// This is present on x64 and also ARM64 systems. On an ARM64 system, ARM64 and AMD64
         /// programs use the same program files directory while 32-bit x86 and ARM programs use two
         /// others. Only a 32-bit has no 64-bit program files directory.
-        maybe_pf_64bit: Result<PathBuf, std::io::Error>,
+        maybe_pf_64bit: Option<PathBuf>,
     }
 
     impl PathsByRole {
@@ -226,7 +229,12 @@ mod tests {
                 .open_subkey_with_flags(r#"SOFTWARE\Microsoft\Windows\CurrentVersion"#, KEY_QUERY_VALUE)
                 .expect("The `CurrentVersion` key exists and allows reading.")
                 .get_value::<OsString, _>("ProgramW6432Dir")
-                .map(PathBuf::from);
+                .map(PathBuf::from)
+                .map_err(|error| {
+                    assert_eq!(error.kind(), ErrorKind::NotFound);
+                    error
+                })
+                .ok();
 
             Self {
                 pf_current,
@@ -261,9 +269,10 @@ mod tests {
                             "The 32-bit program files directory name on a 32-bit system mentions no architecture.",
                         );
                     }
-                    maybe_pf_64bit
-                        .as_ref()
-                        .expect_err("A 32-bit system has no 64-bit program files directory.");
+                    assert_eq!(
+                        maybe_pf_64bit, None,
+                        "A 32-bit system has no 64-bit program files directory.",
+                    );
                 }
                 PlatformArchitecture::Is32on64 => {
                     assert_eq!(