Understanding & and && returns

//http://chat.stackoverflow.com/rooms/85059/discussion-between-imallett-and-matt-mcnabb

References are better thought of as "equivalent" names for things, not fancy pointers.

Semantics:

    `Foo         bar() { return Foo(); }`
    `Foo const c_bar() { return Foo(); }`
Both functions contruct a new `Foo` in their stack space and then return it, copy/move-contructing a `Foo` in the caller's stack space (exactly how varies by the example below).  Then, the callee's locally constructed return value is deleted and the stack popped back to the caller.  Then, possibly some other (semantic) operations occur.

    `Foo       x =   bar(); //example 1`
    `Foo const y = c_bar(); //example 2`
    `Foo const z =   bar(); //example 3`
    `Foo       w = c_bar(); //example 4`
The return value copy/move-constructs a temporary on the caller's stack.  The return value is then destructed.  The temporary then copy/move-constructs `x`, `y`, `z`, or `w` respectively.  The temporary is then destructed.

    `Foo&       x =   bar(); //example 5`
    `Foo&       w = c_bar(); //example 6`
This syntax is illegal.
    `Foo const& y = c_bar(); //example 7`
The return value is copy/move-constructed into a `const` <var> on the caller's stack.  The return value is then destructed.  The <var> is given the name `y`.
    `Foo const& z =   bar(); //example 8`
The return value is copy/move-constructed into a value <temp> on the caller's stack.  The return value is then destructed.  <temp> then copy/move-constructs <var>, which is `const`.  <temp> is then destructed.  <var> is given the name `z`.

    `Foo&&       x =   bar(); //example 9`
    `Foo const&& y = c_bar(); //example 10`
The return value is copy/move-constructed into a <var> on the caller's stack.  The return value is then destructed.  The <var> is then given the name `x` or `y`, respectively.
    `Foo const&& z =   bar(); //example 11`
Exactly the same as example 8.
    `Foo&&       w = c_bar(); //example 12`
This syntax is illegal.

However, in practice, in all of the above, RVO is applied where possible, and extraneous copies are elided.  Optimistically, this forms the following (execution) equivalence classes for the given examples:
	1, 9     //non-const initializing non-const
	2, 7, 10 //    const initializing     const
	3, 8, 11 //non-const initializing     const
	4        //    const initializing non-const (by copy)