+ {merge-lists @<lists> \&key :pick :test :present @> @<list>}
+ Return a merge of the @<lists>, considered as partial orderings.
+
+ In more detail: @<lists> should be a list of lists. Each distinct item, as
+ determined by the @<test> function (by default, @|eql|) appears in the
+ result list exactly once. Furthermore, if, in some input list, an item $x$
+ appears earlier than a different item $y$, then $x$ will also precede $y$
+ in the output list.
+
+ If the input lists contradict each other (e.g., list $A$ has $x$ before
+ $y$, but list $B$ has $y$ before $x$), then an error of type
+ @|inconsistent-merge-error| is signalled, with the offending items attached
+ as candidates, and the function @<present> (by default, @|identity|) as the
+ presentation function.
+
+ Frequently, a collection of input lists has multiple valid merges.
+ Whenever @|merge-lists| must decide between two or more equally good
+ candidates, it calls the @<pick> function to choose one of them.
+ Specifically, it invokes @|(funcall @<pick> @<candidates>
+ @<merge-so-far>)|, where @<candidates> are the items it needs to choose
+ between, and @<merge-so-far> is the currently determined prefix of the
+ final merge. The order of items in the @<candidates> list reflects their
+ order in the input lists: item $x$ precedes item $y$ in @<candidates> if
+ any only if an occurrence of $x$ appears in an earlier input list than
+ $y$. (This completely determines the order of candidates: if two items
+ appear in the same list, then that list would have ordered them and we
+ wouldn't have to call @<pick> to break the tie.) The default @<pick>
+ function simply chooses the item appearing in the earliest list, i.e.,
+ effectively
+ \begin{prog}
+ (lambda (candidates merge-so-far) \\ \ind
+ (declare (ignore merge-so-far)) \\
+ (car candidates))
+ \end{prog}