Minimal call sequence verification implementation

This is the best API I could come up so far. An example of proposed syntax would be something like this:

    var sequence = new CallSequence();
    var mock1 = new Mock<RoleWithSingleSimplestMethod> { CallSequence = sequence };
    var mock2 = new Mock<RoleWithSingleSimplestMethod> { CallSequence = sequence };
    var mock3 = new Mock<RoleWithSingleSimplestMethod>();
    
    mock1.Object.Do();
    mock3.Object.Do();
    mock2.Object.Do();
    
    CallSequence.Verify(
      mock1.CallTo(a => a.Do()),
      mock2.CallTo(b => b.Do())
    );

Regarding discussion in issue #21 :

1. Removed "verify not in sequence" feature for now
2. Changes CallSequence to take parameter of MockBehavior

        var m1 = new Mock<RoleWithSingleSimplestMethod>() 
            { CallSequence = new CallSequence(MockBehavior.Loose) };
    

3. Introduced a shortcut in CallSequence when all mocks have the same sequence:

        CallSequence.Verify(
          m1.CallTo(m => m.Do()),
          m2.CallTo(m => m.Do()))
        );

  A method is exposed on sequence object should anyone require checking more than one sequence:

        sequence.VerifyCalls(
          m1.CallTo(m => m.Do()),
          m2.CallTo(m => m.Do()))
        );

4. Moved the sequencing feature (along with `CallTo...` extension methods) to a separate namespace
5. Introduced extension  points but for now they are hidden because I have no good idea yet on how to deal with Times.XYZ() - for sequences, this is non-trivial, especially when taking into account few combined "at least" and "at most" checks.
6.Exposed CallSequence on MockRepository
Thinking some more, I think this contract represents what an ICallSequence is. Granted, it has a cursor-like behavior, but also has Add... I think given it's named a "sequence", it's ok. 

So this is the sequence, and the "navigation" is the cursor strategy that calls into this one to move.

I'd model the API more like the cursor-like XmlReader, something like:

```
// this one being the exception.
void Add(Mock mock, ICallInfo call);

// Note: this exposes the current position (would be null on initial state and after "EOF", or maybe just the latter?)
// This makes the next method unnecessary, since the strategies could call matcher.Matches(sequence.Current) themselves.
ICallInfo Current { get; }

// Boolean return value makes NextCallExists unnecessary.
bool MoveToNext();

// This being a sequence/cursor, I think it's more idiomatic to just have an EOF property?
bool EOF { get; }   // replaces bool AnyUncheckedCallsLeft();

void Rewind();
```

The following members shouldn't really be needed:
```
// Not needed anymore since we expose Current.
// bool CurrentCallMatches(ICallMatcher expected, Mock target);

// This one doesn't seem to be used by anyone, so I'd kill it.
// bool NextCallMatches(ICallMatchable expected, Mock target);

// This one is used by NextCallMatches, and unless I'm missing something, it's just the same as EOF from its usage.
// bool NextCallExists();

// Another one I don't see used anywhere.
// bool ContainsFurther(ICallMatchable expected, Mock target);

// This one is only called from StrictSequencePartNavigation, so I'd move the logic to that class and remove this method from here. The combination of EOF, MoveToNext and Current (for matching) should be enough for all strategies.
// bool ForwardBeyondSubsequence(List<Tuple<ICallMatchable, Mock>> callsToVerify);
```