Essentially the issue is that I have a structure that is used in two different ways:
Passes data between threads
Is passed to the application to allow it to take certain actions, and return data to the original thread
The issue is that the application "must" take action with the object, so I need a way to convey to the original caller (in a separate thread) if the application didn't take the required action. This is accomplished using the Drop trait, by setting an enum to State::Aborted if it was still in the State::Waiting state. However, this must not happen when these structs are dealt with internally.
It just happens that the same structure can be reused, but the Drop trait must only be implemented for the application-facing struct.
I went with InnerContext and Context, and it's surprisingly non-cluttery. I like it.
Edit: Also opened up another thing -- I can implement Clone on the inner type (which must not be implemented for the application facing object). I now understand better why I see this pattern so often.