Change IVimBufferCoordinator to be self sufficient

The coordinator now is responsible for reseting the discarded key input.
This is an important step to adding a custom KeyProcessor for R#.
Needed to ensure that we had a discernable time frame for exactly when
the KeyInput value would be discarded
Minor test refactor
File rename
Renamed to ReSharperUtil
Another File Rename
Another File Rename
Moved R# key handling to a KeyProcessor

This change moves the special case key processing for R# into a
KeyProcessor.  This allows us to handle the special keys in the
PreviewKeyDown event.

This allows for much more definitive processing than IOleCommandTarget.
R# implements it's own IOleCommandTarget and we end up competing for key
strokes.  The VsVim design is to be resilient to missed / duplicate keys
but missing keys can lead to undesired behavior (such as double Esc to
leave insert when intellisense is up).  Moving to a KeyProcessor is more
reliable because R# at this time doesn't export one.  So I can intercept
the keys much earlier on in the process.

Of course anyone else could implement their own KeyProcessor and jump me
in line.  It's unlikely that R# would do this though and at this time
they don't which makes this more reliable
KeyProcessorSimulation extended to more preview events
ReSharperCommandTarget put in own file

This class needs to evolve quite a bit to allow for better R# testing.
Moving it to it's own file and making it internal to facilitate this
Increased the accuracy of keyboard simulation

The VS key processor should only be routing directly to IOleCommandData
for keys that bind to keyboard commands.  Items such as textual input
should be routed instead to normal keyboard processing
Moved logic back into VsCommandTarget

Moved the R# logic back into the VsCommandTarget.  Keys like Esc and
Back never actually go through the KeyProcessor in normal scenarios but
straight to IOleCommandTarget.  Hence at this time we must have R#
special case logic at this level.  Very unfortunate.  Trying to find a
better way to do this but for now puttnig it back here.
Fixed the failing unit tests

The VsKeyProcessorSimulation still wasn't entirely accurate.  When a key
down event is translated to an executed IOleCommandTarget event it
wasn't running the key up events.  This does not reflect reality.  The
OLE processing is done on key down only and is not a part of key up.
Changed it to reflect key up semantics

Also changed the R# KeyProcessor to respect discarded KeyInput values.
Unit tests are passing again
Create ICommandTarget interface

ICommandTarget will eventually be the plugin point for handling
IOleCommandTarget commands within VsVim.  This step just adds the
interface and factors the relevant code out of VsCommandTarget
Factored out the ReSharper logic into a separate ICommandTarget
Rename of the ReSharper command targets
Remove all R# references from StandardCommandTarget
Cleanup

Fix up some names and remove unneeded fields from the targets
Build fix
Fixed the failing unit tests

Fixed up the unit test to verify the new solution is acceptable.  Very
happy with the results.  Going to push to make this the official model
Resolved majority of TODO values