Add ViMapExcludedFromDot flag on ViMaps.

This flag will be used to determine if a mapping, and
therefore its command, should have its keystrokes excluded
from the record of keys pressed used by the dot (.)
command to repeat the previous insert operation.
Add accessor for isExcludedFromDot to ViCommand.
Don't record keystrokes marked as excluded from dot command in ViTextView.

We also update the insert map’s normal_mode: action
mappings to have that flag; before, we had a hardcoded
check for these action mapping.
Mark <cr> as excluded from dot in the completion map.

This ensures that, when repeating the insert, we don’t
include a newline that indicated where the user had
originally hit <cr> to accept the completion.
Add some curly braces around an else if statement block.
Fix an issue where leaving insert mode with completion up wouldn't set the parser right.

Because by the time normal_mode: runs, the parser has
already been reset to normal mode, but the `mode` instance
variable hasn’t, nuking the completion controller at this
stage was causing the parser to be set back into insert
mode (because the completion controller cancel handler
in ViTextView restores the insert map on close so that the
completion map is no longer in effect).

To deal with this, we now cancel the completion controller
after the text view’s `mode` variable has been set.
Drop the esc key from the completion map.

This lets it fall through to the insert map’s handling of the
esc key, which takes you back to normal mode and cancels
the completion. Before we were only cancelling the
completion, leaving you still in insert mode.
Use hideCompletionWindow in normal_mode:.
Let addChildWindow:ordered: show the completion window.

Before we were explicitly doing an orderFront: first. This
meant that if we had been showing the completion window
in a different space before we tried to bring it up in this
window, the user would get pulled to the previous space and
then pulled back.

That’s obviously not cool ;)
Don't reset the parser to insertMap for field editor.

This is because the field editor isn’t necessarily going back
to the insert map. In particular, the ex field’s field editor
goes back to the ex command map.
Add exCommandCompletionMap.

Before, we were using the regular completion map in the
field editor; however, we need a different map for completion
in the ex command field, since the base keystrokes are
different.

Right now this is identical to the standard completion map
except that it includes the ex command map instead of the
insert map. A couple of attempts to create a base
completion map with the completion keystrokes and then
include that in addition to either the ex map or the insertion
map depending on which completion map we were in didn’t
seem to go so well, so we’ll move on for now.
Set up the ex completion map correctly on each keystroke.

Whenever a keystroke is successfully mapped, the parser
resets, so we need to be ready in cases where the field
editor is showing a completion window to reset the parser
map.
Pass the enabled flag on in setWrapping:duringInit: when passing through.

Before, wrapping would always be forced on if setWrapping:duringInit: was
invoked either not during init or with enabled set to false. Whoops.
Merge branch 'master' into folding-at-home