- Call Annotations.Mark for preserved methods up-front, if the key was already preserved.
  This way we only track preserved methods for things that aren't marked already.
- Track pending preserve info that needs to be applied
- Clean up logic for pending marked members

The Mark* methods in MarkStep "fully" mark members (base types, parameters, etc.), whereas the methods in Annotations only perform a "shallow" mark (they track the fact that this member is to be kept, but they don't process implications of this fact - for example, they may mark methods without marking the containing type).

MarkStep fulfills "shallow" marks by keeping pieces of IL that are required. Each Mark* method in MarkStep now serves two purposes:
- Recursive marking of required IL (for example base types)
  It calls Mark* on everything  that is required, with a "reason" so that this gets traced. The base cases call Annotations.Mark to trace the reason and keep the required IL. After this is done, the original member passed to Mark* is considered "processed". We set the processed bit early enough to ensure that the recursive logic is only performed once.
- Fulfilling "shallow" marks
  Similar to the above, but in this case, it does not need to trace the dependency again (Annotations.Mark has already been called). We need to ensure that it transitions the mark state from "pending" -> "processed" so that anything else which does a shallow mark of the member doesn't introduce new "pending" state.

Call MarkMethod instead of EnqueueMethod so that early-marked
methods get an action assigned. This used to happen in ResolveFromAssemblyStep.

Also fix up typepreserve to correctly track accessibility bits, and
add a testcase for copyused marking behavior.

Fix formatting

And remove currently failing testcase.

- Return arrays instead of IEnumerable for pending Annotations
- Rename methods to Get*
- Add comment for marked_pending
- Don't make state changes inside a Debug assert
- Change sourceLocationMember to null when marking pending types
- Add exception messages

We used to ignore such methods in Initialize, but the new logic for pending marked items will keep the method (and its type) as long as it was marked before MarkStep.

To directly mark an item without adding it to the pending set first.