Have gix-worktree-state checkout tests fail without symlinks

A few of the gix-worktree-state checkout tests have been checking
if the filesystem supports symlinks, while one was skipped (marked
ignored) on Windows based on the idea that symlinks would not be
created, and also had an assertion that assumed symlinks would not
be successfully created.

This commit changes such tests so that they run on all platforms,
including Windows, and so that, on all platforms, they assert that
the filesystem supports symlinks, and assert that expected symlinks
are created after attempts to do so.

(The reason to assert that the filesystem supports symlinks is so
that if this is not detected, either due to a failure or detection
or due to the filesystem really not supporting symlinks, the test
failures will be clear, rather than having a later assertion fail
for unclear reasons.)

Since #1444, tests involving symlinks are expected to work even on
Windows. That PR included changes to the way fixtures were run, and
to other parts of the test suite, to cause symlinks to be created
in cases where they had previously had not (#1443). A number of
tests had been assumed not to work due to limitations of Windows,
MSYS, or Git:

- Although Windows will not allow all users to create symlinks
  under all configurations, the test suite expects to be run on a
  Windows system configured to permit this.

- Although `ln -s` and similar commands in MSYS environments,
  including Git Bash, do not by default attempt to create actual
  symlinks, this does happen when symlink creation is enabled using
  the `MSYS` environment variable, as done in 0899c2e (#1444).

  (This situation differs from that of Unix-style executable bits,
  which do not have filesystem support on Windows. While `chmod +x`
  and `chmod -x` commands do not take effect on Windows, which
  slightly limits the ability to test such metadata and requires
  that a number of fixtures set the mode directly in the ndex, with
  symlinks there is no such inherent restriction. Provided that
  the `MSYS` environment variable is set to allow it, which
  gix-testtools takes care of since #1444, and that Windows permits
  the user running the test suite to create symlinks, which is
  already needed to properly run the test suite on Windows, the
  same `ln -s` commands in fixture scripts that work on Unix-like
  systems will also work on Windows.)

- Although `git` commands will not check out symlinks as actual
  symlinks on Windows unless `core.symlinks` is set to `true`, this
  is not typically required for the way symlinks are used in the
  gitoixde test suite. Instead, we usually test the presence of
  expected symlink metadata in repository data structures such as
  an index and trees, as well as the ability of gitoxide to check
  out symlinks. (We do not intentionally test the ability to run
  `ln -s` in Git Bash, but this is needed in order to create a
  number of the repositories for testing. Having `git` check out
  symlinks is not typically needed for this.)

  In addition, since we are requiring that Windows test
  environments permit the user running the test suite to create
  symlinks, any failures that arise in the future due to greater
  sensitivity to `core.symlinks` (see #1353 for context) could be
  worked around by setting that configuration variable for the
  tests, either in gix-testtools via `GIT_CONFIG_{COUNT,KEY,VALUE}`
  or in the specifically affected fixture scripts.

While #1444 updated a number of tests to reflect the ability to
create symlinks in fixture scripts and the wish to test them on all
platforms including Windows, some tests remain to be updated. This
commit covers the gix-worktree-statte checkout tests.

This does not cover even their associated fixtures, which can
already create symlinks (given the above described conditions), but
that should be updated so they can set intended executable
permissions (see above on `chmod`). This will be done separately.

Author: EliahKagan

gix-worktree-state/tests/state/checkout.rs

@@ -173,20 +173,13 @@ fn delayed_driver_process() -> crate::Result {
 }
 
 #[test]
-#[cfg_attr(
-    windows,
-    ignore = "on windows, the symlink to a directory doesn't seem to work and we really want to test with symlinks"
-)]
 fn overwriting_files_and_lone_directories_works() -> crate::Result {
     for delay in [
         gix_filter::driver::apply::Delay::Allow,
         gix_filter::driver::apply::Delay::Forbid,
     ] {
         let mut opts = opts_from_probe();
-        assert!(
-            opts.fs.symlink,
-            "BUG: the probe must detect to be able to generate symlinks"
-        );
+        assert!(opts.fs.symlink, "The probe must detect to be able to generate symlinks");
         opts.overwrite_existing = true;
         opts.filter_process_delay = delay;
         opts.destination_is_initially_empty = false;
@@ -244,8 +237,7 @@ fn overwriting_files_and_lone_directories_works() -> crate::Result {
         );
 
         let symlink = destination.path().join("dir/sub-dir/symlink");
-        // on windows, git won't create symlinks as its probe won't detect the capability, even though we do.
-        assert_eq!(std::fs::symlink_metadata(&symlink)?.is_symlink(), cfg!(unix));
+        assert!(std::fs::symlink_metadata(&symlink)?.is_symlink());
         assert_eq!(
             std::fs::read(symlink)?.as_bstr(),
             "➡other content\r\n",
@@ -270,10 +262,7 @@ fn symlinks_become_files_if_disabled() -> crate::Result {
 #[test]
 fn symlinks_to_directories_are_usable() -> crate::Result {
     let opts = opts_from_probe();
-    if !opts.fs.symlink {
-        eprintln!("Skipping directory symlink test on filesystem that doesn't support it");
-        return Ok(());
-    }
+    assert!(opts.fs.symlink, "The probe must detect to be able to generate symlinks");
 
     let (_source_tree, destination, _index, outcome) =
         checkout_index_in_tmp_dir(opts.clone(), "make_dir_symlink", None)?;
@@ -298,10 +287,7 @@ fn symlinks_to_directories_are_usable() -> crate::Result {
 #[test]
 fn dangling_symlinks_can_be_created() -> crate::Result {
     let opts = opts_from_probe();
-    if !opts.fs.symlink {
-        eprintln!("Skipping dangling symlink test on filesystem that doesn't support it");
-        return Ok(());
-    }
+    assert!(opts.fs.symlink, "The probe must detect to be able to generate symlinks");
 
     for (fixture, symlink_name, target_name) in [
         ("make_dangling_symlink", "dangling", "non-existing-target"),