RFC for std.math.hypot: "An Improved Algorithm for hypot(a,b)"

[expikr]

I've transcribed the proposed algorithm described in this paper (published https://dl.acm.org/doi/10.1145/3428446) as follows:

// The "Corrected (fused)" algorithm described in https://dl.acm.org/doi/10.1145/3428446
fn hypot_corrected_fused(comptime T: type, x: T, y: T) T {
    const r = @sqrt(@mulAdd(T, x, x, y * y));
    const rr = r * r;
    const xx = x * x;
    const z = @mulAdd(T, -y, y, rr - xx) + @mulAdd(T, r, r, -rr) - @mulAdd(T, x, x, -xx);
    return r - z / (2 * r);
}

The key idea seems to be summarized in this paragraph:

The second existing approach is the code that has been delivered with the stan-
dard C math library since at least 1991. The code appears in appendix B and
we shall refer to it as clib hypot(). It deals with widely varying operands and
prevents intermediate overflow/underflow using methods similar to those we will
use in ours.[footnote 1] It works by using a variety of tricks to artificially extend the precision
of the computed a2 + b2 so that they get a correctly rounded value (or very nearly
so). This is then passed to the sqrt() function. What we will observe in the test-
ing is that all this additional work can be effectively superseded by a single fused
multiply-add.

[footnote 1] There is a clear flaw in the threshold used for widely varying operands and it is much broader
than necessary.

I haven't personally benchmarked the accuracy claims of the paper yet, wondering if folks here might share some thoughts on its veracity and whether it's worth integrating into the stdlib?