This is the first PR that attempts to shift some functionalities of libdebug from a process-scoped to a thread-scoped basis.

I encourage a logical code review, even if it is a draft, to confirm the direction and APIs. I tried to adhere to what we decided together weeks ago, but I had to make some additional decisions.

All the limitations listed below are documented precisely in the code with some TODOs and, where necessary, with warnings for the users.

Why a draft?

• There are still some race conditions in certain multithreaded cases (hence, do not expect the CI to pass).
• The code can be cleaned up and better organized.
• There are a LOT of tests to be done.

What this PR includes

• The control flow operations (continue, finish, next, step, step_until, wait) are now process-scoped when called on the Debugger object and thread-scoped when called on a ThreadContext.
• Defined events (e.g., breakpoints, syscall handlers, signal catchers, ...) can now be set as valid only for a thread. This is a very early version of this feature (see limitations below).
• We now have an InternalThreadContext to hide and manage part of the new complexity introduced. It will be better employed when I address the limitations mentioned above.

What about limitations?

• You can call a control flow function on a single specific thread or on the entire process, but nothing in between.
• Some control flow functions like next and finish are still blocking. I have not changed them to better isolate some race conditions introduced by the new features.
• I still need to implement the equivalent of ensure_process_stopped for a thread to allow access to thread-safe resources when a single thread is stopped but others are running. This is also useful for the first point.
• The running, scheduled, ... flags can be better managed, as can the status flags of the debugger.
• When you handle an event on a thread, you cannot handle the same event on another thread. This is related to the libdebug limitation of one object per event. I will address this with a dedicated PR that will involve a change in how we define events.
• The pretty print of the syscall is not compatible with the thread-scoped handling of a syscall. This issue is related to the previous point.

Why did I not solve these limitations?

Because they are part of other changes that we want to apply to libdebug, which we have not yet implemented. I wanted to avoid adding layers of poor code to circumvent the problems. Also, it is already quite a large PR.