Prevent inadvertent assignment to temporary object - #825

Common porting error coming from languages that have
properties is trying to set a C++/WinRT property by doing

```cpp
o.Property() = value;
```

due to overzealous application of the rule "In C++/WinRT, you
access a property by doing `o.Property()`."

Fix this by making all assignment operators require the
assigned-to variable to be an lvalue, rendering the above
mistake a compile-time error.

Assigning to an rvalue is not interesting because the rvalue
has no name, so you have no way of using the assigned-to
object. There are some wacky fringe cases where you might be
doing this on purpose:

```cpp
get_abi(hstring() = L"Hello")
```

gives you an ABI string handle for a temporary. But this is
decidedly non-idiomatic and I think it's okay to break them.
The idiomatic way of writing this is simply

```cpp
get_abi(hstring(L"Hello"))
```

Assignment operators default to non-ref-qualified, which makes
them applicable to both lvalue and rvalue references. We must
explicitly redeclare them as lvalue ref-qualified in order to
remove the rvalue ref-qualified version.

Once you have an explicit assignment operator, the implicit copy
and move constructors disappear, so we have to bring them back
explicitly.

Once you add explicit copy and move constructors, then
the implicit default constructor disappears. Fortunately,
we never relied upon the implicit default constructor,
so we don't have to to make explicit versions.