perf(data,embed,log): drop allocs across read paths + log formatter

Three lifts found by running the full bench against v0.10.0 and looking
properly at what's still bleeding, not just one pattern.

* Data.resolve — replace SplitN("/") with Index + string-slicing for
  the mount-name + relative-path split. Zero alloc instead of allocating
  a 2-element []string. Every Data.ReadFile / ReadString / List /
  ListNames / Mounts call benefits.

* Embed.path — skip PathJoin when basedir is "" or ".". The canonical
  Mount(fsys, ".") shape is hot and that PathJoin alloc was per-call.

* log writeKV — replace Sprintf("%q") / Sprintf("%v") with
  strconv.AppendQuote / AppendInt / AppendUint / AppendBool /
  AppendFloat into a stack-allocated 64-byte scratch. Zero alloc per
  keyval for string / int / int64 / uint / uint64 / bool / float64
  (the >99% of real log values). Non-trivial types still go through
  Sprintf to preserve behaviour.

Bench impact (Apple M3 Ultra):

  Data.ReadFile_Hit     299 ns / 9 allocs → 187 ns / 5 allocs   1.6x
  Data.ReadString_Hit   355 ns / 11 allocs → 207 ns / 7 allocs  1.7x
  Data.List             484 ns / 13 allocs → 375 ns / 9 allocs  1.3x
  Embed.ReadFile        251 ns / 8 allocs → 162 ns / 5 allocs   1.5x
  Embed.ReadString      274 ns / 10 allocs → 186 ns / 7 allocs  1.5x
  Embed.Sub             187 ns / 5 allocs → 73 ns / 3 allocs    2.6x
  Log.Info_TwoKeyvals   273 ns / 5 allocs → 188 ns / 2 allocs   1.5x
  Log.Warn_SixKeyvals   585 ns / 11 allocs → 345 ns / 2 allocs  1.7x
  Log.Security          305 ns / 6 allocs → 202 ns / 2 allocs   1.5x
  Log.LogErr_Log        416 ns / 9 allocs → 290 ns / 4 allocs   1.4x

Author: Snider

data.go

@@ -71,16 +71,18 @@ func (d *Data) New(opts Options) Result {
 }
 
 // resolve splits a path like "brain/coding.md" into mount name + relative path.
+// Uses Index + string-slicing so the split is zero-alloc — SplitN
+// would allocate a []string of length two plus the slice header.
 func (d *Data) resolve(path string) (*Embed, string) {
-	parts := SplitN(path, "/", 2)
-	if len(parts) < 2 {
+	i := Index(path, "/")
+	if i < 0 {
 		return nil, ""
 	}
-	r := d.Get(parts[0])
+	r := d.Get(path[:i])
 	if !r.OK {
 		return nil, ""
 	}
-	return r.Value.(*Embed), parts[1]
+	return r.Value.(*Embed), path[i+1:]
 }
 
 // ReadFile reads a file by full path.

embed.go

@@ -390,7 +390,19 @@ func MountEmbed(efs embed.FS, basedir string) Result {
 }
 
 func (s *Embed) path(name string) Result {
-	joined := PathToSlash(PathJoin(s.basedir, name))
+	// Fast paths for common mount shapes:
+	//   - basedir "" or "." → name is already the embed-FS path; no
+	//     PathJoin alloc required. (Mount(fsys, ".") is the typical
+	//     consumer shape and hits this branch on every Read/Open.)
+	//   - basedir non-empty → fall through to PathJoin which builds
+	//     the joined path.
+	var joined string
+	switch s.basedir {
+	case "", ".":
+		joined = name
+	default:
+		joined = PathToSlash(PathJoin(s.basedir, name))
+	}
 	if HasPrefix(joined, "..") || Contains(joined, "/../") || HasSuffix(joined, "/..") {
 		return Result{E("embed.path", Concat("path traversal rejected: ", name), nil), false}
 	}

log.go

@@ -8,6 +8,7 @@ package core
 import (
 	"bytes"
 	goio "io"
+	"strconv"
 )
 
 // Level defines logging verbosity.
@@ -248,6 +249,11 @@ func (l *Log) log(level Level, prefix, msg string, keyvals ...any) {
 		}
 	}
 
+	// Scratch buffer reused across keyvals for strconv.AppendX calls.
+	// On stack — no heap alloc unless writeKV's closure escapes (it
+	// doesn't; it only escapes within this function's lifetime).
+	var scratch [64]byte
+
 	writeKV := func(key any, val any) {
 		line.WriteByte(' ')
 		// Fast path: key is already a string (the >99% case for structured logs).
@@ -266,12 +272,27 @@ func (l *Log) log(level Level, prefix, msg string, keyvals ...any) {
 			line.WriteString(keyStr)
 			line.WriteByte('=')
 		}
-		// Value formatting: %q for strings (escapes + quotes), %v for the rest.
-		// Stays on Sprintf for non-trivial types so behaviour matches the
-		// previous formatter byte-for-byte.
-		if s, ok := val.(string); ok {
-			line.WriteString(Sprintf("%q", s))
-		} else {
+		// Value formatting: byte-level fast paths for the common types
+		// (string / int / uint / bool / float64) drive directly into
+		// the line buffer via strconv.AppendX — zero alloc per keyval.
+		// All other types fall through to Sprintf("%v"), matching the
+		// previous behaviour for less common values.
+		switch v := val.(type) {
+		case string:
+			line.Write(strconv.AppendQuote(scratch[:0], v))
+		case int:
+			line.Write(strconv.AppendInt(scratch[:0], int64(v), 10))
+		case int64:
+			line.Write(strconv.AppendInt(scratch[:0], v, 10))
+		case uint:
+			line.Write(strconv.AppendUint(scratch[:0], uint64(v), 10))
+		case uint64:
+			line.Write(strconv.AppendUint(scratch[:0], v, 10))
+		case bool:
+			line.Write(strconv.AppendBool(scratch[:0], v))
+		case float64:
+			line.Write(strconv.AppendFloat(scratch[:0], v, 'g', -1, 64))
+		default:
 			line.WriteString(Sprintf("%v", val))
 		}
 	}