oh boy, did I just write a good chunk of my next blog post??

After all, there's no need for the "specify the operation using an
enum" hack anymore. The two operations can be independant methods, and
the Rust compiler will enforce that both must be implemented!

If a target doesn't implement the `MonitorCmd` extension, then it seems
like a shame to have it include a bunch of unused code related to
parsing + handling `qRcmd` packets, right?

Well, with some clever match guard hinting + the power of Inline Dyn
Extension Traits, it's possible to trick the Rust compiler into
optimizing unused packets out of the final binary!

Now, i'm no compiler engineer, so I can't say whether or not this
optimization is "guaranteed" to occur or not. That said, given how
simple the __protocol_hint method is, and how it can monomorphize to a
static `true / false` boolean, I strongly suspect that it will almost
always perform the optimization.

To assist in implementing + debugging this feature, I've included a new
internal `__dead_code_marker!` macro (and associated feature), which are
used by `script/test_dead_code_elim.sh` to check whether or not a
certain packet is optimized out in the example binaries. See the inline
documentation for how that script works...

Ughh, it took a long while, but I've finally come up with an API for
multiprocess support that I'm happy with, _and_ fixed some icky hacks
and bad implementation choices in the core gdbstub implementation.

Some interesting things that come out of this (chonker of a) commit:

- Turns out the `qC` packet is totally useless, so I've gone ahead and
removed it entirely. The less code the better.
- I've finally fixed the incredibly confusing naming scheme surrounding
the thread-id structures. The new names should be much more sane (and
have less overlap)
- I've massively improved the `resume` method for multithreaded targets.
The key insight is that returning a tuple of `(Tid, StopReason)` wasn't
exactly correct, as there are certain stop reasons that are _not_
associated with any Tid (e.g: GDB interrupt), and it effectively forced
the target to "flip a coin" as to which Tid it reported. This old system
wreaked havoc when dealing with breakpoints in multithreaded systems,
but with the new `ThreadStopReason` API, i've managed to clean up the
library internals to keep the GDB nice and happy, and removed the burden
of making arbitrary decisions from the Targer implementation.
- vCont works now! I'm a dummy, and never actually realized that my
vCont implementation was totally busted. I've gone ahead and fixed it,
so it should be working now.

hmm, not sure when this bug was introduced... Well, it's fixed now, so
that's good.

just a few things that I noticed while rummaging around in the codebase.
they don't really merit individial commits...

While there are still many external types annotated with
`#[derive(Debug)]`, I've removed the debug impls for internal types, to
assist in code size reduction.

Upon further thought, I've realized that using the unit type as the
"unimplemented" RegId type is actually quite detrimental to the end-user
experience. It forces the user to fork `gdbstub` if they want to
implement the `read/write_register` methods for a built in architecure,
which could drive users away...

By passing through the raw GDB identifier, it gives users a chance to
"rough it out" on their own, while urging them to upstream their
implementations as well.