Rewrite Tuple's impl to not be recursive

[danakj]

https://thephd.dev/sol3-compile-times-binary-sizes

The alternative fix is to use a std::tuple. Unfortunately, tuples are a poor idea in practice, especially on VC++ 2017. Currently, VC++’s tuple is implemented recursively, with some 20+ constructors invoked recursively on itself until it reaches the empty tuple. To go back to the 260 elements from before, that’s quite the Russian Doll of template struct instantiations, all different from each other by the order of arguments…! So I either pay the cost of a recursive template instantiation from VC++ tuple (or roll my own tuple, or take one off the shelf from boost::hana), or eat the cost of a recursive function instantiation to process the arguments in order so I can call the function.

These functions are recursive in order to find the Tuple storage for an index:

template <size_t I, class S>
static constexpr const auto& find_tuple_storage(const S& storage) {
  return find_tuple_storage(storage, std::integral_constant<size_t, I>());
}

template <size_t I, class S>
static constexpr const auto& find_tuple_storage(
    const S& storage, std::integral_constant<size_t, I>) {
  return find_tuple_storage(static_cast<const S::Super&>(storage),
                            std::integral_constant<size_t, I - 1>());
}

template <class S>
static constexpr const S& find_tuple_storage(
    const S& storage, std::integral_constant<size_t, 0>) {
  return storage;
}

template <size_t I, class S>
static constexpr auto& find_tuple_storage_mut(S& storage) {
  return find_tuple_storage_mut(storage, std::integral_constant<size_t, I>());
}

template <size_t I, class S>
static constexpr auto& find_tuple_storage_mut(
    S& storage, std::integral_constant<size_t, I>) {
  return find_tuple_storage_mut(static_cast<S::Super&>(storage),
                                std::integral_constant<size_t, I - 1>());
}

template <class S>
static constexpr S& find_tuple_storage_mut(S& storage,
                                           std::integral_constant<size_t, 0>) {
  return storage;
}

Supposedly libc++'s tuple does not require recursion, or maybe this recursion is okay but it has a different type S at each step so I don't think this is okay.

[danakj]

Ah yes and the ctors are recursive:

  template <class... Us>
  constexpr inline TupleStorage(T& value, Us&&... more) noexcept
      : Super(::sus::forward<Us>(more)...),
        value(::sus::mem::addressof(value)) {}

libc++ does some funky multi-inheritance thing which I didn't understand the point of but I guess it's this.