fix(sync): prevent infinite reformat loop on Windows junction fallback

On Windows without Developer Mode, createLink falls back to an NTFS
junction (always absolute). linkNeedsReformat would then return true
on every sync, causing a remove→recreate loop.

Add build-tagged canCreateRelativeLink(): returns true on Unix, and
on Windows probes once with sync.Once by creating a test relative
symlink in a temp dir. linkNeedsReformat skips reformat when the
platform cannot create relative links.

Also use filepath.Clean instead of filepath.Abs in resolveReadlink
(input is already absolute, avoids unnecessary os.Getwd).

Addresses PR #122 review feedback.

Author: runkids

internal/sync/relative.go

@@ -42,5 +42,11 @@ func linkNeedsReformat(dest string, wantRelative bool) bool {
 	if dest == "" {
 		return false
 	}
+	if wantRelative && !canCreateRelativeLink() {
+		// Platform cannot create relative symlinks (e.g. Windows without
+		// Developer Mode falls back to junctions, which are always absolute).
+		// Skip reformat to avoid remove→recreate loop on every sync.
+		return false
+	}
 	return wantRelative == filepath.IsAbs(dest)
 }

internal/sync/symlink_unix.go

@@ -21,6 +21,9 @@ func createLink(linkPath, sourcePath string, relative bool) error {
 	return os.Symlink(target, linkPath)
 }
 
+// canCreateRelativeLink returns true on Unix where os.Symlink always works.
+func canCreateRelativeLink() bool { return true }
+
 // isJunctionOrSymlink checks if path is a symlink
 func isJunctionOrSymlink(path string) bool {
 	info, err := os.Lstat(path)

internal/sync/symlink_windows.go

@@ -10,6 +10,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
+	gosync "sync"
 )
 
 // createLink creates a directory junction on Windows (no admin required).
@@ -73,6 +74,31 @@ func createLink(linkPath, sourcePath string, relative bool) error {
 	return errors.New(errMsg)
 }
 
+// canCreateRelativeLink probes whether the OS can create relative symlinks.
+// On Windows this requires Developer Mode; without it createLink falls back
+// to junctions which are always absolute.
+var relativeProbe struct {
+	once gosync.Once
+	ok   bool
+}
+
+func canCreateRelativeLink() bool {
+	relativeProbe.once.Do(func() {
+		dir, err := os.MkdirTemp("", "ss-relprobe-*")
+		if err != nil {
+			return
+		}
+		defer os.RemoveAll(dir)
+		target := filepath.Join(dir, "t")
+		if err := os.Mkdir(target, 0755); err != nil {
+			return
+		}
+		link := filepath.Join(dir, "l")
+		relativeProbe.ok = os.Symlink("t", link) == nil
+	})
+	return relativeProbe.ok
+}
+
 // isJunctionOrSymlink checks if path is a junction or symlink
 func isJunctionOrSymlink(path string) bool {
 	info, err := os.Lstat(path)