Fix compilation error with CATCH_CONFIG_GLOBAL_NEXTAFTER

Wrong nesting of namespaces resulted in the `Catch` namespace
being ambigous between `::Catch` and `::{anon}::Catch` namespaces.
This should fix it.

Closes #1761

include/internal/catch_matchers_floating.cpp

@@ -22,55 +22,51 @@
 
 
 namespace Catch {
-namespace Matchers {
-namespace Floating {
-enum class FloatingPointKind : uint8_t {
-    Float,
-    Double
-};
-}
-}
-}
-
 namespace {
 
-int32_t convert(float f) {
+    int32_t convert(float f) {
-    static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
+        static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
-    int32_t i;
+        int32_t i;
-    std::memcpy(&i, &f, sizeof(f));
+        std::memcpy(&i, &f, sizeof(f));
-    return i;
+        return i;
-}
-
-int64_t convert(double d) {
-    static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
-    int64_t i;
-    std::memcpy(&i, &d, sizeof(d));
-    return i;
-}
-
-template <typename FP>
-bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
-    // Comparison with NaN should always be false.
-    // This way we can rule it out before getting into the ugly details
-    if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
-        return false;
     }
 
-    auto lc = convert(lhs);
+    int64_t convert(double d) {
-    auto rc = convert(rhs);
+        static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
-
+        int64_t i;
-    if ((lc < 0) != (rc < 0)) {
+        std::memcpy(&i, &d, sizeof(d));
-        // Potentially we can have +0 and -0
+        return i;
-        return lhs == rhs;
     }
 
-    auto ulpDiff = std::abs(lc - rc);
+    template <typename FP>
-    return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
+    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
+        // Comparison with NaN should always be false.
+        // This way we can rule it out before getting into the ugly details
+        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+            return false;
+        }
+
+        auto lc = convert(lhs);
+        auto rc = convert(rhs);
+
+        if ((lc < 0) != (rc < 0)) {
+            // Potentially we can have +0 and -0
+            return lhs == rhs;
+        }
+
+        auto ulpDiff = std::abs(lc - rc);
+        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
+    }
 }
 
 #if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
 
-namespace Catch {
+#if defined(__clang__)
+#pragma clang diagnostic push
+// The long double overload is currently unused
+#pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
     float nextafter(float x, float y) {
         return ::nextafterf(x, y);
     }
@@ -82,10 +78,15 @@ namespace Catch {
     long double nextafter(long double x, long double y) {
         return ::nextafterl(x, y);
     }
-} // end namespace Catch
 
+#if defined(__clang__)
+#pragma clang diagnostic pop
 #endif
 
+#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
+
+namespace {
+
 template <typename FP>
 FP step(FP start, FP direction, uint64_t steps) {
     for (uint64_t i = 0; i < steps; ++i) {
@@ -97,13 +98,17 @@ FP step(FP start, FP direction, uint64_t steps) {
     }
     return start;
 }
-
 } // end anonymous namespace
 
-
-namespace Catch {
 namespace Matchers {
 namespace Floating {
+
+    enum class FloatingPointKind : uint8_t {
+        Float,
+        Double
+    };
+
+
     WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
         :m_target{ target }, m_margin{ margin } {
         CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'