[libcxx/variant] Implement workaround for GCC bug.

[mpark]

Summary

A parameter pack is deemed to be uncaptured, which is bogus... but it seems to
be because it's within an expression that involves decltype of an uncaptured
pack or something: https://godbolt.org/z/b8z3sh

Drive-by fix for uglified name.

libcxx/include/variant

 template <size_t... _Ns, class _Fp>
 inline _LIBCPP_INLINE_VISIBILITY
 static constexpr auto __make_vtable(_Fp __f) {
   using _Tp = decltype(__f(integral_constant<size_t, (_Ns, 0)>{}...));
   return __make_vtable_impl<_Ns...>(__f, _Tp{});
 }
 
 struct __base {
+  template <class _Vis, class... _Vs>
+  struct __dispatch {
+    template <size_t... _Is>
+    inline _LIBCPP_INLINE_VISIBILITY
+    constexpr auto operator()(integral_constant<size_t, _Is>...) const noexcept {
+      return +[](_Vis&& __vis, _Vs&&... __vs) -> decltype(auto) {
+        return __invoke_constexpr(
+            _VSTD::forward<_Vis>(__vis),
+            __access::__base::__get_alt<_Is>(_VSTD::forward<_Vs>(__vs))...);
+      };
+    }
+  };
+
   template <class _Vis, class _Vp, class _Wp>
   inline _LIBCPP_INLINE_VISIBILITY
   static constexpr decltype(auto)
   __visit_alt_at(size_t __index, _Vis&& __vis, _Vp&& __v, _Wp&& __w) {
     constexpr size_t __size = __uncvref_t<_Vp>::__size();
     static_assert(__size == __uncvref_t<_Wp>::__size());
-    constexpr auto __dispatch = [](auto __i) {
-      return +[](_Vis&& __vis_, _Vp&& __v_, _Wp&& __w_) -> decltype(auto) {
-        constexpr size_t _Ip = decltype(__i)::value;
-        return __invoke_constexpr(
-            _VSTD::forward<_Vis>(__vis_),
-            __access::__base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v_)),
-            __access::__base::__get_alt<_Ip>(_VSTD::forward<_Wp>(__w_)));
-      };
+    constexpr auto __dispatch_at = [](auto __i) {
+      return __dispatch<_Vis, _Vp, _Wp>{}(__i, __i);
     };
 #define _LIBCPP_VARIANT_CASE(_Ip)                                              \
   case _Ip: {                                                                  \
     if constexpr (_Ip < __size) {                                              \
-      return __dispatch(integral_constant<size_t, _Ip>{})(                     \
+      return __dispatch_at(integral_constant<size_t, _Ip>{})(                  \
           _VSTD::forward<_Vis>(__vis),                                         \
           _VSTD::forward<_Vp>(__v),                                            \
           _VSTD::forward<_Wp>(__w));                                           \
     } else {                                                                   \
       _LIBCPP_UNREACHABLE();                                                   \
     }                                                                          \
   }
     if constexpr (__size <= _LIBCPP_VARIANT_SWITCH_MAX) {
       switch (__index) {
         _LIBCPP_VARIANT_CASES(_LIBCPP_VARIANT_SWITCH_MAX, _LIBCPP_VARIANT_CASE)
         default: __throw_bad_variant_access();
       }
     } else {
-      constexpr auto __vtable = __make_vtable<__size>(__dispatch);
+      constexpr auto __vtable = __make_vtable<__size>(__dispatch_at);
       return __vtable[__index + 1](_VSTD::forward<_Vis>(__vis),
                                    _VSTD::forward<_Vp>(__v),
                                    _VSTD::forward<_Wp>(__w));
     }
 #undef _LIBCPP_VARIANT_CASE
   }
 
   template <size_t... _Is, class _Vis, class... _Vs>
   inline _LIBCPP_INLINE_VISIBILITY
   static constexpr decltype(auto) __visit_alt(_Vis&& __vis, _Vs&&... __vs) {
     if constexpr (sizeof...(_Vs) == 0) {
       return __invoke_constexpr(_VSTD::forward<_Vis>(__vis));
     } else {
       return __visit_alt_impl(index_sequence_for<_Vs...>{},
                               _VSTD::forward<_Vis>(__vis),
                               _VSTD::forward<_Vs>(__vs)...);
     }
   }
 
   template <size_t... _Is, class _Vis, class... _Vs>
   inline _LIBCPP_INLINE_VISIBILITY
   static constexpr decltype(auto)
   __visit_alt_impl(index_sequence<_Is...>, _Vis&& __vis, _Vs&&... __vs) {
     using __multi = __multi<__uncvref_t<_Vs>::__size()...>;
-    constexpr auto __dispatch = [](auto... __is) {
-      return +[](_Vis&& __vis_, _Vs&&... __vs_) -> decltype(auto) {
-        return __invoke_constexpr(
-            _VSTD::forward<_Vis>(__vis_),
-            __access::__base::__get_alt<decltype(__is)::value>(
-                _VSTD::forward<_Vs>(__vs_))...);
-      };
-    };
+    constexpr __dispatch<_Vis, _Vs...> __dispatch;
 #define _LIBCPP_VARIANT_CASE(_Ip)                                              \
   case _Ip: {                                                                  \
     if constexpr (_Ip < __multi::__size) {                                     \
       return __dispatch(integral_constant<size_t, __itable[_Ip][_Is]>{}...)(   \
           _VSTD::forward<_Vis>(__vis), _VSTD::forward<_Vs>(__vs)...);          \
     } else {                                                                   \
       _LIBCPP_UNREACHABLE();                                                   \
     }                                                                          \

 public:
   using __base_type::__base_type;
   using __base_type::operator=;
 
 protected:
   template <size_t _Ip, class _Tp, class... _Args>
   inline _LIBCPP_INLINE_VISIBILITY
   static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) {
-    auto* result = ::new ((void*)_VSTD::addressof(__a))
+    auto* __result = ::new ((void*)_VSTD::addressof(__a))
         __alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...);
-    return result->__value;
+    return __result->__value;
   }
 
   template <class _Rhs>
   inline _LIBCPP_INLINE_VISIBILITY
   static void __generic_construct(__constructor& __lhs, _Rhs&& __rhs) {
     __lhs.__destroy();
     if (!__rhs.valueless_by_exception()) {
       __visitation::__base::__visit_alt_at(