lib/log+test: wire printfln family onto fmt {n}-parser

Add lprintfln, printfln, lfatalf, fatalf — Hare-shape funcs over the
bb10ee7 fmt.fprintfln + fatalf scaffolding. Logger vtable grows by
one slot (printfln); std and silent loggers both wire the slot in
ensureinit. fatalf composes printfln + os.exit(255) like the existing
fatal arm.

Format-string param is named `format` rather than Hare's `fmt`. With
`use fmt;` at the top, naming the param `fmt: str` shadows the module
ref in body lookups — fmt.fprintfln in the body resolves to the str
param and emits CALL through str.ptr. Silent runtime crash. Filed as
task #19. Rename is reversible after #19.

Tests: 5 new scenarios — basic lprintfln + global dispatch + silent
no-op + indexed `{1} {0}` + modifier `{:5}`. Fatalf arms left TODO
pending the subprocess fixture (same shape as the existing fatal
TODO).

lib/log/log.ww

@@ -3,7 +3,7 @@
 //
 // Surface today:
 //
-//   log.logger     — vtable with a single `println` slot
+//   log.logger     — vtable with `println` + `printfln` slots
 //   log.stdlogger  — first-field embed of logger + a `*io.stream` sink
 //   log.new        (sl: *stdlogger, sink: *io.stream) void
 //   log.silent     *logger — a logger that discards every record
@@ -11,8 +11,12 @@
 //   log.global     *logger — the dispatch target for [[println]] / [[fatal]]
 //   log.println    (args: fmt.formattable...) void
 //   log.lprintln   (log: *logger, args: fmt.formattable...) void
+//   log.printfln   (format: str, fields: fmt.field...) void
+//   log.lprintfln  (log: *logger, format: str, fields: fmt.field...) void
 //   log.fatal      (args: fmt.formattable...) never
 //   log.lfatal     (log: *logger, args: fmt.formattable...) never
+//   log.fatalf     (format: str, fields: fmt.field...) never
+//   log.lfatalf    (log: *logger, format: str, fields: fmt.field...) never
 //   log.setlogger  (log: *logger) void
 //
 // Divergences from Hare:
@@ -32,10 +36,11 @@
 //     [[println]] / [[lprintln]] / [[setlogger]] / etc.) must call
 //     some lib/log fn first so init runs.
 //
-//   • printfln / lprintfln / fatalf / lfatalf are skipped — they
-//     need a fmt {n}-placeholder parser that isn't shipped yet. The
-//     logger vtable carries only `println` today; the format-string
-//     entries graduate with the parser.
+//   • Param name divergence from Hare: the format-string parameter is
+//     `format` (not Hare's `fmt`) because ww's resolver shadows the
+//     `fmt` module reference inside a body when a same-name param is
+//     in scope (silent miscompile — CALL through str.ptr). Tracked as
+//     task #19; rename to `fmt` when fixed.
 //
 // Sink today is [[io.stream]] only — lib/io has no fd-backed stream
 // yet (Hare's `io::handle = file | int` collapses to one variant).
@@ -71,15 +76,12 @@ use fmt;
 use io;
 use os;
 
-// logger — interface for log dispatch. v1 carries a single vtable
-// slot. Hare layers a `printfln` slot for format-string callbacks;
-// that comes back when lib/fmt grows a {n}-placeholder parser.
-//
-// TODO: needs fmt {n}-placeholder parser (future task) — adds a
-// `printfln: fn(l: *logger, fmt: str, args: fmt.field...) void`
-// slot here.
+// logger — interface for log dispatch. Two vtable slots: bare-args
+// `println` (formattable-variadic) and `printfln` (format-string +
+// field-variadic). Mirrors ref/hare/log/logger.ha:9.
 export type logger = struct {
-	println: fn(l: *logger, args: fmt.formattable...) void,
+	println:  fn(l: *logger, args: fmt.formattable...) void,
+	printfln: fn(l: *logger, format: str, fields: fmt.field...) void,
 };
 
 // stdlogger — concrete logger forwarding to a `*io.stream` sink.
@@ -123,9 +125,11 @@ fn ensureinit() void = {
 	stderrsink.write = stderrwrite;
 	stderrsink.close = stderrclose;
 
-	_silent.println = silentprintln;
+	_silent.println  = silentprintln;
+	_silent.printfln = silentprintfln;
 
-	_default.logger.println = stdprintln;
+	_default.logger.println  = stdprintln;
+	_default.logger.printfln = stdprintfln;
 	_default.sink = &stderrsink;
 
 	silent  = &_silent;
@@ -162,18 +166,31 @@ fn stdprintln(l: *logger, args: fmt.formattable...) void = {
 	fmt.fprintln(sl.sink, args...);
 };
 
+// stdprintfln — vtable callback for stdlogger's format-string slot.
+// Mirrors ref/hare/log/logger.ha:38 log_printfln. `format` (not
+// Hare's `fmt`) per the param-name divergence noted in the header.
+fn stdprintfln(l: *logger, format: str, fields: fmt.field...) void = {
+	let sl: *stdlogger = l: *stdlogger;
+	fmt.fprintfln(sl.sink, format, fields...);
+};
+
 // silentprintln — vtable callback for the silent logger. Discards
 // every record without dispatching through fmt; keeps silent truly
 // silent if fmt ever gets stateful.
 fn silentprintln(l: *logger, args: fmt.formattable...) void = { };
 
+// silentprintfln — format-string sibling of [[silentprintln]].
+// Mirrors ref/hare/log/silent.ha:15.
+fn silentprintfln(l: *logger, format: str, fields: fmt.field...) void = { };
+
 // new — wire `sl` as a stdlogger over `sink`. Hare returns by value
 // (ref/hare/log/logger.ha:20); ww cgen can't return wide structs,
 // so we take an out-parameter pointer (same shape as memio.fixed,
 // bufio.init).
 export fn new(sl: *stdlogger, sink: *io.stream) void = {
 	ensureinit();
-	sl.logger.println = stdprintln;
+	sl.logger.println  = stdprintln;
+	sl.logger.printfln = stdprintfln;
 	sl.sink = sink;
 };
 
@@ -212,6 +229,30 @@ export fn setlogger(log: *logger) void = {
 	global = log;
 };
 
-// TODO: needs fmt {n}-placeholder parser (future task) — adds
-// `lprintfln` / `printfln` / `lfatalf` / `fatalf` here once the
-// printfln vtable slot is in place.
+// lprintfln — dispatch a format-string record through `log`. Hare's
+// lib/log/funcs.ha counterpart at line 13.
+export fn lprintfln(log: *logger, format: str, fields: fmt.field...) void = {
+	ensureinit();
+	log.printfln(log, format, fields...);
+};
+
+// printfln — dispatch through the [[global]] logger. Hare's
+// lib/log/funcs.ha counterpart at line 23.
+export fn printfln(format: str, fields: fmt.field...) void = {
+	ensureinit();
+	lprintfln(global, format, fields...);
+};
+
+// lfatalf — lprintfln to `log` then exit(255). Hare's
+// lib/log/funcs.ha counterpart at line 35.
+export fn lfatalf(log: *logger, format: str, fields: fmt.field...) never = {
+	lprintfln(log, format, fields...);
+	os.exit(255);
+};
+
+// fatalf — lprintfln to [[global]] then exit(255). Hare's
+// lib/log/funcs.ha counterpart at line 52.
+export fn fatalf(format: str, fields: fmt.field...) never = {
+	printfln(format, fields...);
+	os.exit(255);
+};