It turns out that we can fix the unit tests of the lockstep_scheduler
just by checking if `passed_lock` is not `nullptr`.

Without this check, the unit tests segfaulted.

The effect was that threads that tried to exit were unnecessarily kept
running.
This did not cause problems except for increased resource usage.

This solves a potential dead-lock when trying to shutdown: a call to exit()
stops all threads and calls all destructors for static objects.
The destructor of LockstepScheduler takes a lock. However this is not
safe, as the lock could already be taken (by any thread).

 - support range based for loops
 - add remove() method to remove a node
 - add clear() to empty entire list and delete nodes
 - add empty() helper

Co-Authored-By: MaEtUgR <maetugr@gmail.com>

ToneAlarm class refactoring to implement an interface for hardware specific methods and a single ToneAlarm class.

Some threads do not exit and are still running when
trying to exit SITL running under Windows in Cygwin.

This problem was introduced with:
- posix shell #10173 because of strating a child process
for the startup script and mixing up the signal handling
(only Ctrl+C broken)
- lockstep #10648 because of simulator threads not
stopping gracefully anymore with timing race conditions
(no graceful exit possible anymore)

I leave the SIGINT handler on its default implementation for
Cygwin which kills the process and all its threads when pressing
Ctrl+C.

This hotfix at least allows the usage of Ctrl+C again instead
of forcing the user to use the task manager to shut down
px4.exe going crazy on CPU load instead of exiting
everytime.

   CONFIG_DISABLE_ENVIRON can prevent task having to allocate
   memory for the env.

GCC did not do that.

This is required as we might be in interrupt context on this bare-metal target.

The actual implementation is not atomic, as the value on the application layer would be limited.

 - starts requirements for PX4 modules (hrt, param, etc)

- use a linked-list instead of std::vector. Insertion and removal are now
  O(1)
- avoid malloc and use a thread_local instance of TimedWait.
  It gets destroyed when the thread exits, so we have to add protection
  in case a thread exits too quickly. This in turn requires a fix to the
  unit-tests.

Previously hrt_absolute_time() was at around 5% of the total CPU usage, now
it's around 0.35%.

less function calls

Not required, since the lock is held during the whole loop iteration.

- the loop is not needed
- we optimize for the fast case and lock only if really needed

This is a small method that is used a lot.