perf(path,io): CleanPath OS-native fast path + WriteString zero-copy fallback

Two more lifts driven by go-mlx hot-path usage tally (PathJoin/JoinPath/
Path 800+ calls, WriteString 318 calls):

* CleanPath: when ds == PathSeparator (the >99% case), delegate to
  stdlib filepath.Clean — byte-level scan vs the Split/Join pipeline.
  Non-OS-native separators fall through to the existing impl.

  Bench impact:
    CleanPath_NoChange  143.5 ns / 6 allocs → 24.1 ns / 0 allocs  6.0x
    CleanPath_DotDot    179.1 ns / 6 allocs → 75.2 ns / 2 allocs  2.4x

* WriteString: when the writer exposes WriteString (strings.Builder,
  bytes.Buffer, *os.File), delegate. For writers without one, swap
  stdlib io.WriteString's []byte(s) copy for AsBytes(s) — safe under
  the io.Writer contract (implementations must not retain or mutate
  the slice past the call).

  Bench impact:
    WriteString_Short    ~7 ns / 1 alloc → 4.97 ns / 0 allocs   1.4x
    WriteString_1KB      ~30 ns          → 18.65 ns / 1 alloc

go-mlx hot-path audit found these were the two remaining wins; the
inference per-token path itself runs through core primitives at
near-zero alloc (Sprintf only fires on error branches that don't hit
in steady state, Env is cached, error construction is one alloc).

Author: Snider

io.go

@@ -125,8 +125,22 @@ func CopyN(dst Writer, src Reader, n int64) Result {
 // the number of bytes written (int).
 //
 //	r := core.WriteString(stdout, "hello\n")
+//
+// Fast path: when the writer exposes a WriteString method we delegate
+// straight to it (strings.Builder, bytes.Buffer, *os.File on most
+// platforms). For writers without one, we use AsBytes to skip the
+// []byte(s) copy that stdlib io.WriteString does in its fallback —
+// safe because the io.Writer contract forbids retention or mutation
+// of the slice past the call.
 func WriteString(w Writer, s string) Result {
-	n, err := io.WriteString(w, s)
+	if sw, ok := w.(interface{ WriteString(string) (int, error) }); ok {
+		n, err := sw.WriteString(s)
+		if err != nil {
+			return Result{err, false}
+		}
+		return Result{n, true}
+	}
+	n, err := w.Write(AsBytes(s))
 	if err != nil {
 		return Result{err, false}
 	}

path.go

@@ -155,10 +155,17 @@ func PathIsAbs(p string) bool {
 //
 //	core.CleanPath("/tmp//file", "/")     // "/tmp/file"
 //	core.CleanPath("a/b/../c", "/")       // "a/c"
+//
+// Fast path: when ds is the OS-native separator (the >99% case),
+// delegate to stdlib filepath.Clean — byte-level scan, 2 allocs vs
+// the Split/Join pipeline's 6.
 func CleanPath(p, ds string) string {
 	if p == "" {
 		return "."
 	}
+	if ds == string(PathSeparator) {
+		return filepath.Clean(p)
+	}
 
 	rooted := HasPrefix(p, ds)
 	parts := Split(p, ds)