[libc++] Remove conditional usage of rvalue references in C++03

[ldionne]

Summary

This one is easy -- Clang supports rvalue references in C++03 mode, so
we should be able to remove that conditional.

[philnik]

libcxx/include/exception

329

Maybe also std::forward instead of static_casting?

[ldionne]

Address comments and rebase (should fix CI).

[Mordante]

LGTM!

libcxx/include/exception

 #include <__memory/addressof.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_base_of.h>
 #include <__type_traits/is_class.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_copy_constructible.h>
 #include <__type_traits/is_final.h>
 #include <__type_traits/is_polymorphic.h>
+#include <__utility/forward.h>
 #include <cstddef>
 #include <cstdlib>
 #include <version>
 
 // <vcruntime_exception.h> defines its own std::exception and std::bad_exception types,
 // which we use in order to be ABI-compatible with other STLs on Windows.
 #if defined(_LIBCPP_ABI_VCRUNTIME)
 #  include <vcruntime_exception.h>

 template <class _Tp, class _Up, bool>
 struct __throw_with_nested;
 
 template <class _Tp, class _Up>
 struct __throw_with_nested<_Tp, _Up, true> {
     _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void
     __do_throw(_Tp&& __t)
     {
-        throw __nested<_Up>(static_cast<_Tp&&>(__t));
+        throw __nested<_Up>(std::forward<_Tp>(__t));
     }
 };
 
 template <class _Tp, class _Up>
 struct __throw_with_nested<_Tp, _Up, false> {
     _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void
-#ifndef _LIBCPP_CXX03_LANG
     __do_throw(_Tp&& __t)
-#else
-    __do_throw (_Tp& __t)
-#endif // _LIBCPP_CXX03_LANG
     {
-        throw static_cast<_Tp&&>(__t);
+        throw std::forward<_Tp>(__t);
     }
 };
 #endif
 
 template <class _Tp>
 _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
 void
 throw_with_nested(_Tp&& __t)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     typedef typename decay<_Tp>::type _Up;
     static_assert( is_copy_constructible<_Up>::value, "type thrown must be CopyConstructible");
     __throw_with_nested<_Tp, _Up,
         is_class<_Up>::value &&
         !is_base_of<nested_exception, _Up>::value &&
         !__libcpp_is_final<_Up>::value>::
-            __do_throw(static_cast<_Tp&&>(__t));
+            __do_throw(std::forward<_Tp>(__t));
 #else
     ((void)__t);
     // FIXME: Make this abort
 #endif
 }
 
 template <class _From, class _To>
 struct __can_dynamic_cast : _BoolConstant<