Revise extending tuple struct constructor examples

The example for the tuple enum variant constructor should go above the
example that already uses a tuple enum variant constructor in a nested
manner.  This also matches the order in the list of extending
expressions above -- the list items for tuple struct constructors and
tuple enum variant constructors come after tuple expressions and
before block expressions.

For demonstrating a tuple enum variant constructor, it's better to use
`Some(_)` than to define one; `Option<T>` is well known enough.

For the tuple struct that we need to define, let's use a short name
like `W<T>` here rather than `TupleStruct<T>` (and show its
definition).  When I see a name like `TupleStruct`, it takes me a
moment to confirm it's just a name and not more than that.  We use
this `W<T>(T)` "wrapper" tuple struct definition elsewhere in the
Reference.

As a wording matter, we say "argument to" rather than "argument of".

Similarly, something isn't an argument to a tuple struct but an
argument to the tuple struct constructor, so let's say that.

Author: traviscross

src/destructors.md

@@ -524,15 +524,12 @@ let x = &temp() as &dyn Send; // Operand of cast.
 # x;
 let x = (&*&temp(),); // Operand of tuple constructor.
 # x;
-let x = { [Some(&temp())] }; // Final expr of block.
+struct W<T>(T);
+let x = W(&temp()); // Argument to tuple struct constructor.
 # x;
-# struct TupleStruct<T>(T);
-let x = TupleStruct(&temp()); // Argument of tuple struct.
+let x = Some(&temp()); // Argument to tuple enum variant constructor.
 # x;
-# enum Enum<T> {
-#     TupleVariant(T),
-# }
-let x = Enum::TupleVariant(&temp()); // Argument of tuple enum variant.
+let x = { [Some(&temp())] }; // Final expr of block.
 # x;
 let x = const { &temp() }; // Final expr of `const` block.
 # x;