wording: store the error as unexpected<E> in expected<T&, E>

An "as-if" exposition of the error as a union member E unex cannot
represent the documented behavior: when E is an lvalue reference, E& is
not a permissible union member. Specify the error member as unexpected<E>
instead, which holds a pointer via unexpected<E&> for a reference E, and
route error access through unex.error(). Update the dependent member
descriptions (copy ctor, unexpect_t effects, error(), rebinding
assignment) to match, and add a General paragraph stating why.

Verified: build clean at 93 pages; stripped diff vs expected-base.tex
still removes exactly 3 lines (all in the relaxation edits, none here).

Author: steve-downey

papers/expected-new.tex

@@ -2988,23 +2988,27 @@
     friend constexpr bool operator==(const expected&, const unexpected<E2>&);
 
 private:
-  bool @\exposid{has_val}@;         // \expos
+  bool @\exposid{has_val}@;           // \expos
   union {
-    T* @\exposid{val}@;             // \expos
-    E @\exposid{unex}@;             // \expos
+    T* @\exposid{val}@;               // \expos
+    unexpected<E> @\exposid{unex}@;   // \expos
   };
 };
 \end{codeblock}
 
 \pnum
-Any object of type \tcode{expected<T\&, E>} either
-represents a reference to an object of type \tcode{T}, or
-contains a value of type \tcode{E} nested within\iref{intro.object} it.
-Member \exposid{has_val} indicates whether the \tcode{expected<T\&, E>} object
-represents a reference.
-When an \tcode{expected<T\&, E>} object represents a reference,
-member \exposid{val} points to the referenced object,
-which is not owned by the \tcode{expected} object.
+An object of type \tcode{expected<T\&, E>} either represents a reference to an
+object of type \tcode{T}, or holds an error.
+Member \exposid{has_val} indicates whether the object represents a reference.
+When it represents a reference, member \exposid{val} points to the referenced
+object, which is not owned by the \tcode{expected} object.
+Otherwise, the error is \tcode{\exposid{unex}.error()}.
+
+\pnum
+The error is held as an \tcode{unexpected<E>}, and not as an \tcode{E}, so that
+\tcode{E} can be an lvalue reference type: an \tcode{E\&} cannot be a union
+member, whereas \tcode{unexpected<E\&>} holds a pointer to an external
+object\iref{expected.un.ref}.
 
 \pnum
 A program that instantiates the definition of
@@ -3030,8 +3034,8 @@
 \effects
 If \tcode{rhs.has_value()} is \tcode{true}, initializes \exposid{val} with
 \tcode{rhs.\exposid{val}}, so that \tcode{*this} and \tcode{rhs} refer to the
-same object; otherwise, initializes \exposid{unex} with the error of
-\tcode{rhs}.
+same object; otherwise, initializes \exposid{unex} with
+\tcode{rhs.\exposid{unex}}.
 
 \pnum
 \ensures
@@ -3162,7 +3166,10 @@
 
 \pnum
 \effects
-Initializes \exposid{unex} with the given arguments.
+Direct-non-list-initializes \exposid{unex} with \tcode{in_place} and
+\tcode{std::forward<Args>(args)...} (respectively, \tcode{in_place},
+\tcode{il}, and \tcode{std::forward<Args>(args)...}), so that the error
+\tcode{\exposid{unex}.error()} is constructed from those arguments.
 \tcode{has_value()} is \tcode{false}.
 \end{itemdescr}
 
@@ -3258,9 +3265,10 @@
 
 \pnum
 \effects
-Makes \tcode{*this} hold the error of \tcode{e}. When \tcode{E} is a reference
-type, \exposid{unex} is made to refer to the same object as \tcode{e.error()};
-the previously referenced object, if any, is not modified.
+Makes \tcode{*this} hold the error of \tcode{e}, reinitializing \exposid{unex}
+from \tcode{e} rather than assigning through it. When \tcode{E} is a reference
+type, \tcode{\exposid{unex}.error()} thereafter refers to the same object as
+\tcode{e.error()}; the previously referenced object, if any, is not modified.
 
 \pnum
 \returns
@@ -3402,8 +3410,8 @@
 
 \pnum
 \returns
-A reference to the error, as for the primary template
-(\ref{expected.object.obs}).
+\tcode{\exposid{unex}.error()}, with the \tcode{const} and reference
+qualification of the selected overload.
 \end{itemdescr}
 
 \indexlibrarymember{value_or}{expected}%