style: adopt TigerStyle across src/; add docs/TIGER_STYLE.md

Wrap signatures and long expressions to the 100-column limit and make every
file zig fmt clean. Semantics-preserving throughout: ignoring whitespace and
the trailing commas that wrapping introduces, every file here is byte-identical
to its predecessor, and the one apparent exception is a warning string split
with `++`, which concatenates at comptime to the same bytes.

src/index.zig and src/commands.zig are reformatted in the commits that follow,
because their reformat is interleaved with in-flight changes to them and
separating the two would need the reformat re-derived rather than moved.

src/server.zig

@@ -120,7 +120,10 @@ fn handle_connection_inner(io: std.Io, stream: std.Io.net.Stream, server: *Serve
         reader.interface.readSliceAll(&len_bytes) catch return; // clean client disconnect (EOF or RST)
         const total: u32 = std.mem.readInt(u32, &len_bytes, .little);
         if (total < 16 or total > wire.max_message_size) {
-            std.debug.print("multiforadb: bad message length {d} on conn {d}\n", .{ total, connection_id });
+            std.debug.print("multiforadb: bad message length {d} on conn {d}\n", .{
+                total,
+                connection_id,
+            });
             return;
         }
 
@@ -129,14 +132,22 @@ fn handle_connection_inner(io: std.Io, stream: std.Io.net.Stream, server: *Serve
         msg_buf.items.len = total;
         std.mem.writeInt(u32, msg_buf.items[0..4], total, .little);
         reader.interface.readSliceAll(msg_buf.items[4..]) catch |err| {
-            std.debug.print("multiforadb: read error on conn {d}: {s} (body, len {d})\n", .{ connection_id, @errorName(err), total });
+            std.debug.print("multiforadb: read error on conn {d}: {s} (body, len {d})\n", .{
+                connection_id,
+                @errorName(err),
+                total,
+            });
             return;
         };
 
         var msg = wire.Message.parse(server.gpa, msg_buf.items) catch |err| {
             // Unparseable request: close the connection.
             const op: i32 = if (msg_buf.items.len >= 16) std.mem.readInt(i32, msg_buf.items[12..16], .little) else 0;
-            std.debug.print("multiforadb: bad message on conn {d}: {s} (opCode {d})\n", .{ connection_id, @errorName(err), op });
+            std.debug.print("multiforadb: bad message on conn {d}: {s} (opCode {d})\n", .{
+                connection_id,
+                @errorName(err),
+                op,
+            });
             return;
         };
         defer msg.deinit();
@@ -146,7 +157,11 @@ fn handle_connection_inner(io: std.Io, stream: std.Io.net.Stream, server: *Serve
         commands.dispatch(&ctx, &msg, &reply) catch |err| {
             // Discard any partial reply (the client would read the first
             // ok field, which may already say 1) and send a clean error.
-            std.debug.print("multiforadb: dispatch error on conn {d} cmd {s}: {s}\n", .{ connection_id, msg.command_name(), @errorName(err) });
+            std.debug.print("multiforadb: dispatch error on conn {d} cmd {s}: {s}\n", .{
+                connection_id,
+                msg.command_name(),
+                @errorName(err),
+            });
             reply.pairs.clearRetainingCapacity();
             reply.put_error(
                 @intFromEnum(commands.ErrorCode.internal_error),
@@ -161,16 +176,25 @@ fn handle_connection_inner(io: std.Io, stream: std.Io.net.Stream, server: *Serve
         else
             reply.build(server.gpa, reply_request_id, msg.request_id, &out_buf);
         built catch |err| {
-            std.debug.print("multiforadb: reply build error on conn {d}: {s}\n", .{ connection_id, @errorName(err) });
+            std.debug.print("multiforadb: reply build error on conn {d}: {s}\n", .{
+                connection_id,
+                @errorName(err),
+            });
             return;
         };
         reply_request_id +%= 1;
         writer.interface.writeAll(out_buf.items) catch |err| {
-            std.debug.print("multiforadb: write error on conn {d}: {s}\n", .{ connection_id, @errorName(err) });
+            std.debug.print("multiforadb: write error on conn {d}: {s}\n", .{
+                connection_id,
+                @errorName(err),
+            });
             return;
         };
         writer.interface.flush() catch |err| {
-            std.debug.print("multiforadb: flush error on conn {d}: {s}\n", .{ connection_id, @errorName(err) });
+            std.debug.print("multiforadb: flush error on conn {d}: {s}\n", .{
+                connection_id,
+                @errorName(err),
+            });
             return;
         };
     }