[move-only] Add a new CheckKind::AssignableButNotConsumable.

This is used to model global_addr/ref_element_addr/escaping closure captures
where we do not want to allow the user to consume the memory (leaving the memory
in a potentially uninitialized state), but we do want to allow for the user to
assign over the memory all at once.

Consider a situation like the following:

```
@_moveOnly
struct FileDescriptor {
  var state: CInt = ...
}

final class Klass {
   var descriptor = ...
}

func consumeDescriptor(_ x: __owned FileDescriptor) {}

// Eventually both of these will point at the same class.
var globalKlass = ...
var globalKlass2 = ...

func memoryUnsafe() {
     consumeDescriptor(globalKlass.descriptor)
     consumeDescriptor(globalKlass2.descriptor)
}

func callMemoryUnsafe() {
     globalKlass2 = globalKlass()
     memoryUnsafe()
}
```

Notice how in the above in memoryUnsafe, locally the compiler has no way of
knowing that globalKlass and globalKlass2 actually point at the same class and
thus we are attempting to consume the same descriptor twice. This is even
allowed by exclusivity. If descriptor was not move only, this would be safe
since we would just copy the value when we consume it. But b/c we ar3e using
move only, we must take from the memory.

Author: gottesmm

include/swift/SIL/SILInstruction.h

@@ -8208,18 +8208,26 @@ class MarkMustCheckInst
   enum class CheckKind : unsigned {
     Invalid = 0,
 
-    // A signal to the move only checker to perform checking that allows for
-    // this value to be consumed along its boundary (in the case of let/var
-    // semantics) and also written over in the case of var semantics. NOTE: Of
-    // course this still implies the value cannot be copied and can be consumed
-    // only once along all program paths.
+    /// A signal to the move only checker to perform checking that allows for
+    /// this value to be consumed along its boundary (in the case of let/var
+    /// semantics) and also written over in the case of var semantics. NOTE: Of
+    /// course this still implies the value cannot be copied and can be consumed
+    /// only once along all program paths.
     ConsumableAndAssignable,
 
-    // A signal to the move only checker to perform no consume or assign
-    // checking. This forces the result of this instruction owned value to never
-    // be consumed (for let/var semantics) or assigned over (for var
-    // semantics). Of course, we still allow for non-consuming uses.
+    /// A signal to the move only checker to perform no consume or assign
+    /// checking. This forces the result of this instruction owned value to never
+    /// be consumed (for let/var semantics) or assigned over (for var
+    /// semantics). Of course, we still allow for non-consuming uses.
     NoConsumeOrAssign,
+
+    /// A signal to the move checker that the given value cannot be consumed,
+    /// but is allowed to be assigned over. This is used for situations like
+    /// global_addr/ref_element_addr/closure escape where we do not want to
+    /// allow for the user to take the value (leaving the memory in an
+    /// uninitialized state), but we are ok with the user assigning a new value,
+    /// completely assigning over the value at once.
+    AssignableButNotConsumable,
   };
 
 private:
@@ -8244,6 +8252,7 @@ class MarkMustCheckInst
       return false;
     case CheckKind::ConsumableAndAssignable:
     case CheckKind::NoConsumeOrAssign:
+    case CheckKind::AssignableButNotConsumable:
       return true;
     }
   }

lib/SIL/IR/SILPrinter.cpp

@@ -1998,6 +1998,9 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     case CheckKind::NoConsumeOrAssign:
       *this << "[no_consume_or_assign] ";
       break;
+    case CheckKind::AssignableButNotConsumable:
+      *this << "[assignable_but_not_consumable] ";
+      break;
     }
     *this << getIDAndType(I->getOperand());
   }

lib/SIL/Parser/ParseSIL.cpp

@@ -3666,6 +3666,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
             .Case("consumable_and_assignable",
                   CheckKind::ConsumableAndAssignable)
             .Case("no_consume_or_assign", CheckKind::NoConsumeOrAssign)
+            .Case("assignable_but_not_consumable", CheckKind::AssignableButNotConsumable)
             .Default(CheckKind::Invalid);
 
     if (CKind == CheckKind::Invalid) {