Assign the member that lookups find when set() meets duplicate keys

An editable document reads the last member of a repeated key (as the
read-only document does), but set(object, key, value) assigned the first
one: a view taken from object[key] before the call did not show the new
value. It now assigns the last member's value, keeps the key at the
position of its first occurrence (where materialize() puts it), and drops
the other members.

The seeded differential test now also edits documents whose objects
repeat keys and compares every lookup (operator[], at, find, value,
contains, count, and JSON pointers) with the parsed basic_json value.
A targeted test covers duplicates before and after edits that move the
object, in large objects with an index, in moved arrays, and in values
copied from other documents.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

docs/mkdocs/docs/api/basic_json_document/erase.md

@@ -86,8 +86,8 @@ view of a *different* document (overloads 1-2 only; overload 3 always starts fro
 
 !!! info "Duplicate keys"
 
-    Overload 1. removes *every* member with `key`, not just the first -- unlike [`set`](set.md), which assigns the
-    first occurrence and drops the rest. This is why it returns a count rather than a single view: there may be
+    Overload 1. removes *every* member with `key`, not just the last one that lookups find -- unlike [`set`](set.md),
+    which assigns that member and drops the rest. This is why it returns a count rather than a single view: there may be
     more than one member removed, or none.
 
 Like [`set`](set.md) and [`push_back`](push_back.md), `erase` never moves an element's *value*: a view still

docs/mkdocs/docs/api/basic_json_document/set.md

@@ -23,7 +23,8 @@ has `set`; calling it on a read-only `basic_json_document` fails to compile (`#!
 
 1. Replaces the value `target` refers to with `value`.
 2. Sets the member `key` of the object `object` to `value`: assigns it if `object` already has a member with this
-   key -- the first one, should the key occur more than once, and the later duplicates are then dropped (see the
+   key -- the last one, should the key occur more than once (the member
+   [`operator[]`](../basic_json_view/operator%5B%5D.md) returns), and the other duplicates are then dropped (see the
    [Notes](#notes) below) -- or appends a new member at the end otherwise. A [null](../basic_json_view/is_null.md)
    `object` first becomes an empty object.
 3. Assigns `value` to the element at index `idx` of the array `array`, which must already exist (`#!cpp idx <
@@ -146,12 +147,13 @@ document") if `target`/`object`/`array` is a [discarded](../basic_json_view/is_d
 
 !!! info "Duplicate keys"
 
-    If `object` already has more than one member with `key` (2.), the *first* one is assigned `value` and every
-    later member with the same key is removed -- so that a lookup, an iteration, and
-    [`materialize()`](../basic_json_view/materialize.md) of `object` afterward all agree on a single value for
-    `key`, the same way [`operator[]`](../basic_json_view/operator%5B%5D.md) already picks the first occurrence of a
-    duplicate key for reading. See the [Notes on duplicate keys](../basic_json_view/operator%5B%5D.md#notes) of
-    `operator[]`.
+    If `object` already has more than one member with `key` (2.), `value` is assigned to the *last* one -- the member
+    [`operator[]`](../basic_json_view/operator%5B%5D.md), [`at`](../basic_json_view/at.md), and
+    [`find`](../basic_json_view/find.md) return for reading, so that a view taken from `object["key"]` before the call
+    shows `value` afterward -- and every other member with the same key is removed. The key stays at the
+    position of its *first* occurrence, where [`materialize()`](../basic_json_view/materialize.md) puts it as well. A
+    lookup, an iteration, and `materialize()` of `object` afterward therefore all agree on a single member for `key`. See the
+    [Notes on duplicate keys](../basic_json_view/operator%5B%5D.md#notes) of `operator[]`.
 
 Setting a member (2.) or an element (3., through 4.) of an array or object whose elements have not been edited
 before switches it from its parsed layout to a growable block holding links to its elements; a later