A common error when using tt(lock_guards) is defining it as an anonymous
object:
        verb(    void Class::notLocked()
    {
        lock_guard<mutex>{d_mutex};

        // using data available to multiple threads
    })
    In cases like these, since the tt(lock_guard) is defined as an anonymous
object, it's immediately destroyed after its construction offering no guard
against multiple threads using the shared data.

Traditionally this situation is solved by explicitly defining an object. The
object's name is irrelevant, because it's used nowhere else, resulting in
constructions like
        verb(    void Class::lockedOK()
    {
        lock_guard<mutex> guard{d_mutex};

        // using data available to multiple threads
    })
    But in this context the name's irrelevant and not used nowhere elsew in
the function.

Since the C++26 standard, however, a generalized alternative approach
is available. It's called 
        hi(_ variable name)emi(name-independent declaration)
    Very simple (and broadly applicable), requiring tt(--std=c++26) or
beyond, which is supported since tt(g++-14).

The 'name' bf(_) (a single underscore) results in a name-independent
declaration. It's definitely em(not) a name we would use for 'common'
variables, but starting with the C++26 standard a variable named `_' implies a
name-independent declaration. So in 'tt(lockedOK)' we can now do:
        verb(    void Class::lockedOK()
    {
        lock_guard<mutex> _{d_mutex};

        // using data available to multiple threads
    })
    and we never have to think again about how to name a required (but not
used by us) variable or object. As long as there's no ambiguity it's even
possible to define multiple `_' variables or objects. As long as they're not
being used by name it's possible to define, e.g.,
        verb(    void neverUsed()
    {
        int _{12};
        int _{43};      // a different int because of the initialization
        auto _ = 42;            // 'auto' also works fine
        auto _("hello world");  // a string...
    })
    But in practice, use name independent declarations as illustrated in the
above tt(lockedOK) function.
