Can `factorize_ceili()` be rewritten such that no overflow can occur?

[mbeutel]

The two overloads of factorize_floori() always succeed (provided the preconditions hold) because they were carefully written to avoid any possible overflow. However, both factorize_ceili() overloads can currently overflow. I suspect that factorize_ceili() could also be reformulated such that no overflow can occur overflows occur in fewer cases (e.g. the related log_ceili() is overflow-free).

[mbeutel]

An example of an avoidable overflow:

std::uint32_t x = std::uint32_t(-1); // = 2³² - 1
auto [r, e] = factorize_ceili(x, std::uint32_t(2));
// expected outcome: r = 1, e = 32, i.e. x = 2ᵉ - r
// actual outcome: overflow error

As long as r is representable in the given type, we'd want factorize_ceili() to succeed.

But as implied by this condition, there are arguments for which factorize_ceili() must fail with an overflow, e.g.

std::uint32_t M = std::uint32_t(-1); // = 2³² - 1
std::uint32_t x = M;
std::uint32_t b = M - 1;
auto [r, e] = factorize_ceili(x, b);
// overflow error: x = bᵉ + r with e = 2, but r = bᵉ - x = (M - 1)² - M = M² - 3M + 1 > M.