Added `is_sendable<T>()` intrinstic for introspection on T.

This is analogous to the `owns_managed<T>` intrinsic.  The goal in
this case is to be able to discriminate between ~T and ~[T] for T:Send
versus !T:Send, in order to maintain metadata for conservative
scanning (which AFAICT will need to extend outward from the
roots+stack to owned data in the exchange heap).

Hopefully we will eventually be able to do precise stack scanning, at
which time discriminating in this manner won't be necessary (or at
least we will not need to build up or at least use the metadata here).
But for a conservative stack scan, we need some way to track interior
pointers into, and the extents of, ~owned memory on the exchange heap.
add some local sro play files.

Still exploring register walking code.

Still not clear on what I'm doing wrong but OS X's malloc/free is
complaining at me about modifies-post-free.

Added debug flags during debugging of sro-play.rs.

Not sure they actually buy me anything here (they did not seem to help
in tracking down the `dump_registers` overwrite issue).

isolated test case for -Z extra-debug-info issue.

But I should look into the error I was seeing, because the erroneous
behavior does not exactly match my expectations for how it would
manifest itself.  (But it could easily be that I just have not
digested the task-local RC cleanup code.)

Choice now: Encode some graph structured examples, or start work on
copying gc?  (Before doing the latter, should ensure examples have
some portions that are not reachable from the stack, either via
iteration or via scoping.)
Adapted rt dump_registers function from graydon's gc branch.
just playing around while reading graydon's old work on gc.

Expose Registers struct so that one can walk the registers in a
conservative GC scheme.

(but try to discourage forging of hand-made register sets by adding a
private NonCopyable member).

An important change to fix dump_registers was establishing the fxsave
area, as noted in the comment.

Also changed callback signature to take third argument (of type `*()`)
in an attempt to ensure that it will always be safe to tail-call from
a call to `dump_registers` over to the callback.

Adding tydesc argument to `exchange_malloc` to enable dynamic tracking
of ~T allocations, which in turn supports conservative scanning of
roots+stack holding pointers to ~T's and into their interiors.

Also, if we have `global_raw`, it is most consistent IMO to also
provide `free_raw`.

Checkpoint attempts to get things building atop
libgreen and revised TyDesc handling.