[concepts.equality] Add missing paragraph numbers, reorder implicit

expression variations in example for clarity and to fix overfull hbox.

Author: zygoloid

source/concepts.tex

@@ -77,6 +77,7 @@
 requirements of the declared expression. The extent to which an implementation
 validates the syntax of the variations is unspecified.
 
+\pnum
 \begin{example}
 \begin{codeblock}
 template<class T> concept C = requires(T a, T b, const T c, const T d) {
@@ -86,30 +87,40 @@
 };
 \end{codeblock}
 
+For the above example:
+\begin{itemize}
+\item
 Expression \#1 does not modify either of its operands, \#2 modifies both of its
 operands, and \#3 modifies only its first operand \tcode{a}.
 
+\item
 Expression \#1 implicitly requires additional expression variations that meet
 the requirements for \tcode{c == d} (including non-modification), as if the
 expressions
 \begin{codeblock}
-a == d;                       a == b;                       a == std::move(b); a == std::move(d);
-c == a;                       c == std::move(a);            c == std::move(d);
-std::move(a) == d;            std::move(a) == b;
-std::move(a) == std::move(b); std::move(a) == std::move(d);
-std::move(c) == b;            std::move(c) == std::move(b);
-std::move(c) == d;            std::move(c) == std::move(d);
+                                            c  ==           b;
+          c  == std::move(d);               c  == std::move(b);
+std::move(c) ==           d;      std::move(c) ==           b;
+std::move(c) == std::move(d);     std::move(c) == std::move(b);
+
+          a  ==           d;                a  ==           b;
+          a  == std::move(d);               a  == std::move(b);
+std::move(a) ==           d;      std::move(a) ==           b;
+std::move(a) == std::move(d);     std::move(a) == std::move(b);
 \end{codeblock}
 had been declared as well.
 
+\item
 Expression \#3 implicitly requires additional expression variations that meet
 the requirements for \tcode{a = c} (including non-modification of the second
 operand), as if the expressions \tcode{a = b} and \tcode{a = std::move(c)} had
 been declared. Expression \#3 does not implicitly require an expression
 variation with a non-constant rvalue second operand, since expression \#2
 already specifies exactly such an expression explicitly.
+\end{itemize}
 \end{example}
 
+\pnum
 \begin{example}
 The following type \tcode{T} meets the explicitly stated syntactic requirements
 of concept \tcode{C} above but does not meet the additional implicit
@@ -125,7 +136,7 @@
 \tcode{T} fails to meet the implicit requirements of \tcode{C}, so \tcode{C<T>}
 is not satisfied. Since implementations are not required to validate the syntax
 of implicit requirements, it is unspecified whether an implementation diagnoses
-as ill-formed a program which requires \tcode{C<T>}.
+as ill-formed a program that requires \tcode{C<T>}.
 \end{example}
 
 \rSec1[concepts.syn]{Header \tcode{<concepts>} synopsis}