db: a write that changes nothing is not a write

`nModified` counted every write, so an update that altered nothing was reported
as a modification. MongoDB counts a document as modified only if applying the
update changed it, and writes no oplog entry when it did not: `$set: {x: 11}`
on a document already holding `x: 11` is matched and not modified. The spec
suite says it plainly -- `bulkWrite` with four updateOne operations expects
matchedCount 2 and modifiedCount 1.

Decided in the engine rather than the command, because that is where the
document is already serialized: the comparison is against the bytes that would
actually be stored, and it lands before the log append, so a no-op costs no log
record, no fsync, no slab bytes and no garbage. `Engine.replace` returns
`Written.modified` or `.unchanged` and `cmd_update` counts the first.

That exposed a second difference. A replacement keeps `_id` at the front, so
replacing a document with itself was a byte-level change whenever `_id` was not
stored first -- and it usually was not: the Node driver fills a missing `_id` by
assigning the property, which in JavaScript appends it, so `insertOne({name,
age})` reaches the server as `{name, age, _id}` and we stored it that way.
MongoDB moves `_id` to the front whatever order it arrives in. Now so does
`serialize_with_id`, for every document rather than only the ones whose `_id` it
generates. Visible to clients as `_id` coming back first, as it does from
MongoDB.

  spec scorecard   161 pass / 131 fail  ->  163 pass / 129 fail
  bulkWrite.json   8 pass / 2 fail      ->  10 pass / 0 fail
  e2e.js           45 checks -> 49

No spec file regressed. Mutation: delete the byte comparison in `upsert`'s
`.replace` arm -- red on the log growing, on the garbage counters moving, and on
`replace` claiming `.modified`.

src/commands.zig

@@ -920,7 +920,7 @@ fn cmd_update(ctx: *Context, msg: *wire.Message, reply: *wire.Reply) !void {
                 error.ImmutableId, error.InvalidUpdate => return bad_value(reply, "bad update"),
                 else => return err,
             };
-            ctx.engine.replace(db_name, coll_name, copy, ctx.oid_gen) catch |err| switch (err) {
+            const written = ctx.engine.replace(db_name, coll_name, copy, ctx.oid_gen) catch |err| switch (err) {
                 error.DuplicateKey, error.DuplicateKeyIndex => {
                     const e = try reply.arena_alloc().alloc(bson.Pair, 3);
                     e[0] = .{ .key = "index", .value = .{ .int32 = @intCast(si) } };
@@ -931,7 +931,10 @@ fn cmd_update(ctx: *Context, msg: *wire.Message, reply: *wire.Reply) !void {
                 },
                 else => return err,
             };
-            n_modified += 1;
+            // `n` counts matches, `nModified` counts documents the update
+            // actually altered. A write that would store the same bytes is
+            // neither logged nor counted here.
+            if (written == .modified) n_modified += 1;
         }
     }
 
@@ -1040,7 +1043,9 @@ fn cmd_find_and_modify(ctx: *Context, msg: *wire.Message, reply: *wire.Reply) !v
             error.ImmutableId, error.InvalidUpdate => return bad_value(reply, "bad update"),
             else => return err,
         };
-        try ctx.engine.replace(db_name, coll_name, copy, ctx.oid_gen);
+        // findAndModify reports `n` (matched) and `updatedExisting`, neither of
+        // which distinguishes a no-op, so whether it wrote is not needed here.
+        _ = try ctx.engine.replace(db_name, coll_name, copy, ctx.oid_gen);
         n = 1;
         updated_existing = true;
         value = if (ret_new) try project_doc(reply, copy, proj_pairs) else .{ .doc = before };