[NFC] add llvm namespace to Optional and None

This is phase-1 of switching from llvm::Optional to std::optional in the
next rebranch. llvm::Optional was removed from upstream LLVM, so we need
to migrate off rather soon. On Darwin, std::optional, and llvm::Optional
have the same layout, so we don't need to be as concerned about ABI
beyond the name mangling. `llvm::Optional` is only returned from one
function in
```
getStandardTypeSubst(StringRef TypeName,
                     bool allowConcurrencyManglings);
```
It's the return value, so it should not impact the mangling of the
function, and the layout is the same as `std::optional`, so it should be
mostly okay. This function doesn't appear to have users, and the ABI was
already broken 2 years ago for concurrency and no one seemed to notice
so this should be "okay".

I'm doing the migration incrementally so that folks working on main can
cherry-pick back to the release/5.9 branch. Once 5.9 is done and locked
away, then we can go through and finish the replacement. Since `None`
and `Optional` show up in contexts where they are not `llvm::None` and
`llvm::Optional`, I'm preparing the work now by going through and
removing the namespace unwrapping and making the `llvm` namespace
explicit. This should make it fairly mechanical to go through and
replace llvm::Optional with std::optional, and llvm::None with
std::nullopt. It's also a change that can be brought onto the
release/5.9 with minimal impact. This should be an NFC change.

lib/ConstExtract/ConstExtract.cpp

@@ -192,7 +192,7 @@ static llvm::Optional<std::string> extractRawLiteral(Expr *expr) {
       break;
     }
   }
-  return None;
+  return llvm::None;
 }
 
 static std::shared_ptr<CompileTimeValue> extractCompileTimeValue(Expr *expr) {
@@ -242,17 +242,17 @@ static std::shared_ptr<CompileTimeValue> extractCompileTimeValue(Expr *expr) {
           auto elementExpr = std::get<0>(pair);
           auto elementName = std::get<1>(pair);
 
-          Optional<std::string> label =
+          llvm::Optional<std::string> label =
               elementName.empty()
-                  ? Optional<std::string>()
-                  : Optional<std::string>(elementName.str().str());
+                  ? llvm::None
+                  : llvm::Optional<std::string>(elementName.str().str());
 
           elements.push_back({label, elementExpr->getType(),
                               extractCompileTimeValue(elementExpr)});
         }
       } else {
         for (auto elementExpr : tupleExpr->getElements()) {
-          elements.push_back({Optional<std::string>(), elementExpr->getType(),
+          elements.push_back({llvm::None, elementExpr->getType(),
                               extractCompileTimeValue(elementExpr)});
         }
       }
@@ -291,7 +291,7 @@ static std::shared_ptr<CompileTimeValue> extractCompileTimeValue(Expr *expr) {
         auto declRefExpr = cast<DeclRefExpr>(fn);
         auto caseName =
             declRefExpr->getDecl()->getName().getBaseIdentifier().str().str();
-        return std::make_shared<EnumValue>(caseName, None);
+        return std::make_shared<EnumValue>(caseName, llvm::None);
       }
 
       break;
@@ -443,10 +443,10 @@ extractEnumCases(NominalTypeDecl *Decl) {
         std::vector<EnumElementParameterValue> Parameters;
         if (const ParameterList *Params = EED->getParameterList()) {
           for (const ParamDecl *Parameter : Params->getArray()) {
-            Optional<std::string> Label =
+            llvm::Optional<std::string> Label =
                 Parameter->getParameterName().empty()
-                    ? Optional<std::string>()
-                    : Optional<std::string>(
+                    ? llvm::None
+                    : llvm::Optional<std::string>(
                           Parameter->getParameterName().str().str());
 
             Parameters.push_back({Label, Parameter->getType()});
@@ -454,7 +454,7 @@ extractEnumCases(NominalTypeDecl *Decl) {
         }
 
         if (Parameters.empty()) {
-          Elements.push_back({Name, RawValue, None});
+          Elements.push_back({Name, RawValue, llvm::None});
         } else {
           Elements.push_back({Name, RawValue, Parameters});
         }
@@ -463,7 +463,7 @@ extractEnumCases(NominalTypeDecl *Decl) {
     return Elements;
   }
 
-  return None;
+  return llvm::None;
 }
 
 ConstValueTypeInfo