Add isApproximatelyEqual for RandomAccessCollection

[jkrukowski]

I think it would be useful to add isApproximatelyEqual for RandomAccessCollection. When working with numerical computations on collections of floating-point values (e.g., vectors, matrices represented as arrays), it's common in tests to need element-wise approximate equality comparisons. The API would mirror the existing scalar versions:

extension RandomAccessCollection where Element: Numeric, Element.Magnitude: FloatingPoint {
  @inlinable @inline(__always)
  public func isApproximatelyEqual(
    to other: Self,
    relativeTolerance: Element.Magnitude = Element.Magnitude.ulpOfOne.squareRoot(),
    norm: (Element) -> Element.Magnitude = \.magnitude
  ) -> Bool {
    return isApproximatelyEqual(
      to: other,
      absoluteTolerance: relativeTolerance * Element.Magnitude.leastNormalMagnitude,
      relativeTolerance: relativeTolerance,
      norm: norm
    )
  }

  @inlinable @inline(__always)
  public func isApproximatelyEqual(
    to other: Self,
    absoluteTolerance: Element.Magnitude,
    relativeTolerance: Element.Magnitude = 0
  ) -> Bool {
    return isApproximatelyEqual(
      to: other,
      absoluteTolerance: absoluteTolerance,
      relativeTolerance: relativeTolerance,
      norm: \.magnitude
    )
  }
}

extension RandomAccessCollection where Element: AdditiveArithmetic {
  @inlinable
  public func isApproximatelyEqual<Magnitude>(
    to other: Self,
    absoluteTolerance: Magnitude,
    relativeTolerance: Magnitude = 0,
    norm: (Element) -> Magnitude
  ) -> Bool
  where Magnitude: FloatingPoint {
    guard self.count == other.count else { return false }
    for (lhs, rhs) in zip(self, other) {
      if !lhs.isApproximatelyEqual(
        to: rhs,
        absoluteTolerance: absoluteTolerance,
        relativeTolerance: relativeTolerance,
        norm: norm
      ) {
        return false
      }
    }
    return true
  }
}

I'm happy to submit a PR with tests if this sounds reasonable.

[stephentyrone]

For vectors or matrices the usual thing would be to compare them with a vector or operator norm, rather than elementwise (tight componentwise errors are not feasible for most linear algebra routines).

I'm open to defining something like this, but it probably wants to have an explicit "elementwise" in the name somewhere (or maybe almostEqualElements or similar).