What this PR does (for future reference):

Previously, the C/C++ part of the runtime had only arraylist_t and small_arraylist_t for lists of things, neither of which are inherently thread-safe and need an external lock.

This PR adds small_mtarraylist_t which is basically a small_arraylist_t with atomics that allows multiple threads to safely read pushes and adds (which have implicit resizes when necessary) concurrently with a single writer thread.

Three lists in ptls->heap are converted to small_mtarraylist_ts -- weak_refs, live_tasks and free_stacks and the code that touches these has been updated to use the new thread-safe accessors.

Then, jl_live_tasks() is also updated and, it looks like, hardened somewhat to handle foreign threads and GC threads correctly.

There are some changes to the signal_listener and jl_thread_suspend_and_get_state and jl_thread_resume that I think are used by the profiling mechanism but I'm not very clear on what's going on there.

All that essentially enables: jl_rec_backtrace() is improved to not simply skip over sticky tasks or tasks running on other threads; it now uses jl_thread_suspend_and_get_state to stop the thread and get its state (which includes the backtrace). And jl_print_task_backtraces() is updated to use the correct (small_mtarraylist_t) calls to access live_tasks.

what's the difference between an arraylist_t and a Julia Vector (which we can also use from the C side?

An arraylist_t is not a safepoint, and as such, cannot hold GC references and cannot be reclaimed by the GC. In most cases, Vector{Int} is the preferable thing to use, if the GC is available and initialized on that thread.

The previous implementation of this capability was insufficiently safe and segfaults on occasion, so this is actually a bugfix. Can we backport it to 1.10 @vtjnash and @KristofferC?

If so, #51471 should be backported also.