The `Assert`/`Assume` macros are implemented via lambda functions to allow the result of the assertion to both be evaluated (and trigger an abort) and be returned without having the expression be evaluated twice.

This causes some ugly namespacing issues though. Because there's a function call, clang's thread safety annotations don't get passed through (as the lambda is unannotated), possibly causing an unnecessary compiler error because the compiler loses track that a mutex is held when a guarded variable is accessed.

It also seems that gcc (but not clang) gets confused about member functions (but not member variables), eg:

```c++
class TestAssert
{
public:
    int variable = 3;
    int test_1(void) { return variable; }
    int test_2(void) {
        auto x = [&]() {
            Assert(test_1() == 3);
        };
        x();
        return ++variable;
    }
};
```

results in:

```
test/util_tests.cpp:91:26: error: cannot call member function ‘int util_tests::TestAssert::test_1()’ without object
   91 |             Assert(test_1() == 3);
```

requiring you to write `Assert(this->test_1() == 3)` instead.
Tracker(const Tracker& t) noexcept : origin(t.origin), copies(t.copies + 1) {}
    Tracker(Tracker&& t) noexcept : origin(t.origin), copies(t.copies) {}
    Tracker& operator=(const Tracker& t) noexcept
    {
        origin = t.origin;
        copies = t.copies + 1;
        return *this;
    }
};
}
BOOST_AUTO_TEST_CASE(test_tracked_vector)
{
    Tracker t1;
    Tracker t2;
    Tracker t3;
    BOOST_CHECK(t1.origin == &t1);
    BOOST_CHECK(t2.origin == &t2);
    BOOST_CHECK(t3.origin == &t3);