[NFC][libcxxabi] Rename GlobalLock to GlobalMutex

[DanielMcIntosh-IBM]

Summary

This will make the naming more consistent with what it's called in the
rest of the file.

This is the 1st of 5 changes to overhaul cxa_guard.
See D108343 for what the final result will be.

[DanielMcIntosh-IBM]

Update description with a bit more detail

[DanielMcIntosh-IBM]

(I'm waiting for the other 5 related PRs to get approved before landing to reduce the number of times we have to resolve merge conflicts downstream)

[DanielMcIntosh-IBM]

No change, just re-trigger CI so later dependent changes update their base revision

libcxxabi/src/cxa_guard_impl.h

 
 template <class T>
 struct GlobalStatic {
   static T instance;
 };
 template <class T>
 _LIBCPP_SAFE_STATIC T GlobalStatic<T>::instance = {};
 
-enum class Implementation { NoThreads, GlobalLock, Futex };
+enum class Implementation { NoThreads, GlobalMutex, Futex };
 
 template <Implementation Impl>
 struct SelectImplementation;
 
 template <>
 struct SelectImplementation<Implementation::NoThreads> {
   using type = InitByteNoThreads;
 };
 
 template <>
-struct SelectImplementation<Implementation::GlobalLock> {
+struct SelectImplementation<Implementation::GlobalMutex> {
   using type = InitByteGlobalMutex<LibcppMutex, LibcppCondVar, GlobalStatic<LibcppMutex>::instance,
                                    GlobalStatic<LibcppCondVar>::instance, PlatformThreadID>;
 };
 
 template <>
 struct SelectImplementation<Implementation::Futex> {
   using type = InitByteFutex<PlatformFutexWait, PlatformFutexWake, PlatformThreadID>;
 };
 
 // TODO(EricWF): We should prefer the futex implementation when available. But
 // it should be done in a separate step from adding the implementation.
 constexpr Implementation CurrentImplementation =
 #if defined(_LIBCXXABI_HAS_NO_THREADS)
     Implementation::NoThreads;
 #elif defined(_LIBCXXABI_USE_FUTEX)
     Implementation::Futex;
 #else
-    Implementation::GlobalLock;
+    Implementation::GlobalMutex;
 #endif
 
 static_assert(CurrentImplementation != Implementation::Futex || PlatformSupportsFutex(),
               "Futex selected but not supported");
 
 using SelectedImplementation = SelectImplementation<CurrentImplementation>::type;
 
 } // end namespace

libcxxabi/test/guard_test_basic.pass.cpp

 
 int main(int, char**) {
   {
 #if defined(_LIBCXXABI_HAS_NO_THREADS)
     static_assert(CurrentImplementation == Implementation::NoThreads, "");
     static_assert(
         std::is_same<SelectedImplementation, InitByteNoThreads>::value, "");
 #else
-    static_assert(CurrentImplementation == Implementation::GlobalLock, "");
+    static_assert(CurrentImplementation == Implementation::GlobalMutex, "");
     static_assert(
         std::is_same<
             SelectedImplementation,
             InitByteGlobalMutex<LibcppMutex, LibcppCondVar,
                                 GlobalStatic<LibcppMutex>::instance,
                                 GlobalStatic<LibcppCondVar>::instance>>::value,
         "");
 #endif

libcxxabi/test/guard_threaded_test.pass.cpp

for (auto test_func : TestList) {
           test_func(ThreadsPerTest);
         }
       });
       test_threads.JoinAll();
     }
   }
 
 void test_all_impls() {
-  using MutexImpl = SelectImplementation<Implementation::GlobalLock>::type;
+  using MutexImpl = SelectImplementation<Implementation::GlobalMutex>::type;
 
   // Attempt to test the Futex based implementation if it's supported on the
   // target platform.
   using RealFutexImpl = SelectImplementation<Implementation::Futex>::type;
   using FutexImpl = typename std::conditional<
       PlatformSupportsFutex(),
       RealFutexImpl,
       MutexImpl