optimize integer_sequence when no builtin is available

when `T` is other than `std::size_t` (here `int`):

compiler |      gcc-15       |     clang-20
before   | 0:00.14s - 47220K | 0:00.23s - 107632K
after    | 0:00.12s - 42344K | 0:00.23s - 107344K

when `T` is `std::size_t`:

compiler |      gcc-15       |     clang-20
before   | 0:00.13s - 46600K | 0:00.22s - 107228K
after    | 0:00.09s - 39808K | 0:00.15s - 94860K

```cpp
using T = int;

template<class I> using test
  = make_integer_sequence<T, I::value>;

using r1 = mp_transform<test, mp_iota_c<200>>;
```

Author: jonathanpoelen

include/boost/mp11/integer_sequence.hpp

@@ -47,60 +47,42 @@ template<class T, T N> using make_integer_sequence = integer_sequence<T, __integ
 // detail::make_integer_sequence_impl
 namespace detail
 {
+template<bool, std::size_t N, class L>
+struct iseq_expand;
 
-// iseq_if_c
-template<bool C, class T, class E> struct iseq_if_c_impl;
-
-template<class T, class E> struct iseq_if_c_impl<true, T, E>
-{
-    using type = T;
-};
-
-template<class T, class E> struct iseq_if_c_impl<false, T, E>
+template<std::size_t N, std::size_t... I>
+struct iseq_expand<false, N, integer_sequence<std::size_t, I...>>
 {
-    using type = E;
+    using type = integer_sequence<std::size_t, I..., (N+I)...>;
 };
 
-template<bool C, class T, class E> using iseq_if_c = typename iseq_if_c_impl<C, T, E>::type;
-
-// iseq_identity
-template<class T> struct iseq_identity
+template<std::size_t N, std::size_t... I>
+struct iseq_expand<true, N, integer_sequence<std::size_t, I...>>
 {
-    using type = T;
+    using type = integer_sequence<std::size_t, I..., (N+I)..., N * 2>;
 };
 
-template<class S1, class S2> struct append_integer_sequence;
+template<class T, class L> struct convert_integer_sequence;
 
-template<class T, T... I, T... J> struct append_integer_sequence<integer_sequence<T, I...>, integer_sequence<T, J...>>
+template<class T, std::size_t... I> struct convert_integer_sequence<T, integer_sequence<std::size_t, I...>>
 {
-    using type = integer_sequence< T, I..., ( J + sizeof...(I) )... >;
+  using type = integer_sequence<T, I...>;
 };
 
-template<class T, T N> struct make_integer_sequence_impl;
-
-template<class T, T N> struct make_integer_sequence_impl_
+template<class T, T N> struct make_integer_sequence_impl
 {
-private:
-
     static_assert( N >= 0, "make_integer_sequence<T, N>: N must not be negative" );
 
-    static T const M = N / 2;
-    static T const R = N % 2;
-
-    using S1 = typename make_integer_sequence_impl<T, M>::type;
-    using S2 = typename append_integer_sequence<S1, S1>::type;
-    using S3 = typename make_integer_sequence_impl<T, R>::type;
-    using S4 = typename append_integer_sequence<S2, S3>::type;
-
-public:
-
-    using type = S4;
+    using type = typename convert_integer_sequence<T, typename make_integer_sequence_impl<std::size_t, N>::type>::type;
 };
 
-template<class T, T N> struct make_integer_sequence_impl: iseq_if_c<N == 0, iseq_identity<integer_sequence<T>>, iseq_if_c<N == 1, iseq_identity<integer_sequence<T, 0>>, make_integer_sequence_impl_<T, N> > >
+template<std::size_t N> struct make_integer_sequence_impl<std::size_t, N> : iseq_expand<N & 1, N / 2, typename make_integer_sequence_impl<std::size_t, N / 2>::type>
 {
 };
 
+template<> struct make_integer_sequence_impl<std::size_t, 0> { using type = integer_sequence<std::size_t>; };
+template<> struct make_integer_sequence_impl<std::size_t, 1> { using type = integer_sequence<std::size_t, 0>; };
+
 } // namespace detail
 
 // make_integer_sequence