Fix xsimd_neon64.hpp for MSVC ARM64

Two issues newly exposed after fixing xsimd_neon.hpp:

1. reducer_return_type_impl used explicit template specializations.
   On MSVC ARM64 all NEON vector types share the same underlying __n128
   type, so all specializations clashed (C2766: already defined).
   Replace with a primary template using std::conditional chains,
   following the same pattern as comp_return_type_impl in xsimd_neon.hpp.

2. WRAP_CAST used ::vreinterpretq_f64_* calls. On MSVC ARM64,
   vreinterpretq_* are macros that expand to cast expressions starting
   with '(', so ::macro(x) becomes ::(cast)... which MSVC rejects
   (C2589: illegal token after ::). Drop :: from those calls.

Note: WRAP_REDUCER wrappers keep :: because the wrapper function has
the same name as the intrinsic (no x_ prefix), making :: necessary to
avoid recursion. Reducer intrinsics are actual functions on MSVC ARM64
(not macros), so :: works correctly there.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: AntoinePrv

include/xsimd/arch/xsimd_neon64.hpp

@@ -947,67 +947,41 @@ namespace xsimd
 
         namespace detail
         {
-            template <class R>
-            struct reducer_return_type_impl;
-
-            template <>
-            struct reducer_return_type_impl<uint8x16_t>
-            {
-                using type = uint8_t;
-            };
-
-            template <>
-            struct reducer_return_type_impl<int8x16_t>
-            {
-                using type = int8_t;
-            };
-
-            template <>
-            struct reducer_return_type_impl<uint16x8_t>
-            {
-                using type = uint16_t;
-            };
-
-            template <>
-            struct reducer_return_type_impl<int16x8_t>
-            {
-                using type = int16_t;
-            };
-
-            template <>
-            struct reducer_return_type_impl<uint32x4_t>
-            {
-                using type = uint32_t;
-            };
-
-            template <>
-            struct reducer_return_type_impl<int32x4_t>
-            {
-                using type = int32_t;
-            };
-
-            template <>
-            struct reducer_return_type_impl<uint64x2_t>
-            {
-                using type = uint64_t;
-            };
-
-            template <>
-            struct reducer_return_type_impl<int64x2_t>
-            {
-                using type = int64_t;
-            };
-
-            template <>
-            struct reducer_return_type_impl<float32x4_t>
-            {
-                using type = float;
-            };
-
-            template <>
-            struct reducer_return_type_impl<float64x2_t>
+            // On MSVC ARM64, all NEON vector types share the same underlying __n128 type,
+            // making explicit template specialization impossible (C2766). Use a primary
+            // template with std::conditional chains instead, matching the pattern used
+            // for comp_return_type_impl in xsimd_neon.hpp.
+            template <class T>
+            struct reducer_return_type_impl
             {
-                using type = double;
+                using type = typename std::conditional<
+                    std::is_same<T, uint8x16_t>::value,
+                    uint8_t,
+                    typename std::conditional<
+                        std::is_same<T, int8x16_t>::value,
+                        int8_t,
+                        typename std::conditional<
+                            std::is_same<T, uint16x8_t>::value,
+                            uint16_t,
+                            typename std::conditional<
+                                std::is_same<T, int16x8_t>::value,
+                                int16_t,
+                                typename std::conditional<
+                                    std::is_same<T, uint32x4_t>::value,
+                                    uint32_t,
+                                    typename std::conditional<
+                                        std::is_same<T, int32x4_t>::value,
+                                        int32_t,
+                                        typename std::conditional<
+                                            std::is_same<T, uint64x2_t>::value,
+                                            uint64_t,
+                                            typename std::conditional<
+                                                std::is_same<T, int64x2_t>::value,
+                                                int64_t,
+                                                typename std::conditional<
+                                                    std::is_same<T, float32x4_t>::value,
+                                                    float,
+                                                    double>::type>::type>::type>::type>::type>::type>::type>::type>::type;
             };
 
             template <class R>
@@ -1359,11 +1333,11 @@ namespace xsimd
     {                                                                             \
         XSIMD_INLINE float64x2_t(x_vreinterpretq_f64_##SUFFIX)(TYPE a) noexcept   \
         {                                                                         \
-            return ::vreinterpretq_f64_##SUFFIX(a);                               \
+            return vreinterpretq_f64_##SUFFIX(a);                                 \
         }                                                                         \
         XSIMD_INLINE TYPE(x_vreinterpretq_##SUFFIX##_f64)(float64x2_t a) noexcept \
         {                                                                         \
-            return ::vreinterpretq_##SUFFIX##_f64(a);                             \
+            return vreinterpretq_##SUFFIX##_f64(a);                               \
         }                                                                         \
     }