AS-265: delete server (review)

`DELETE .../groupId/servers/serverId` endpoint implemented that will delete specific server from the group. It takes optional `replace` query argument that tells whether to replace the deleted server by creating new one. The default is `True`.

Tested with [crest](https://github.com/manishtomar/crest) (Yes! I am going to brag it in every PR :D) and it works fine :)
> Will return not self == other implementation for __ne__ help? This way only eq needs to be implemented.

Sorry, I should have explained myself first.  :) I think the current implementation of `__ne__` is a bug, so I think it needs to be implemented in terms of the matcher too.  I'm wondering if we want to say in the repr whether the previous match was an equals test or ne test.

    >>> 'one' != matches(Equals('two'))
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "otter/test/utils.py", line 56, in __ne__
        return self != other
      File "otter/test/utils.py", line 56, in __ne__
        return self != other
      ...
      RuntimeError: maximum recursion depth exceeded

>I am not sure if this is required. Are you suggesting to raise an error if __eq__ is called again? I can't think of situation when that will happen and even then I think caller should be interested in last match?

You're right, it will likely not happen again.  I guess that's not really my objection, I was just trying to think of a way to make me like this more.  I like that there would be a more informative message in the test tracebacks, I'm just not sure I like the form it takes.

So currently, some code like `self.assertEqual({'one': 'c'}, matches(ContainsDict({'one': Equals('d')})))` produces the following:

    twisted.trial.unittest.FailTest: not equal:
    a = {'one': 'c'}
    b = matches(ContainsDict({'one': Equals('d')})

In this branch, it produces the following output:

    twisted.trial.unittest.FailTest: not equal:
    a = {'one': 'c'}
    b = mismatch: Differences: {
      'one': 'd' != 'c',
    }

Which doesn't seem entirely accurate: `b` is indeed a matches object, not a mismatch message.  The first message was more accurate in that the two are not equivalent.  It seems like the mismatch message should actually be part of the error message, not the repr of the thing that is being compared.

The ideal message is something like:

    twisted.trial.unittest.FailTest:  {'one': 'c'} does not match ContainsDict({'one': Equals('d')})
       Differences: {
         'one': 'd' != 'c',
       }

It seems like we really want twisted to have a `self.assertMatches`, but perhaps it would be sufficient to have an `assertMatches` function that just causes raises `FailTest` (caveat, instead of actually raising the message ourselves, we could use `assertIsNone` on the match result, with the error message passed to `assertIsNone` being the description)?  This won't improve the test failure messages for our existing usage of matches, or with its usage in `some_mock.assert_called_once_with`, but we seem to be trying to move away from mock/behavior testing and more toward stub/state testing

And we can test in the future with the `assertMatches` function instead of using `matches` around one of those testtool matchers.  It'd be nice to just have a function that does what we actually want.