Improve shootout-reverse-complement.rs using unsafe code

This is some improvement as asked and discused here: http://www.reddit.com/r/rust/comments/2j2ij3/benchmark_improvement_reverse_compliment/

Before:
```
real    0m0.396s
user    0m0.280s
sys     0m0.112s
```
after:
```
real    0m0.293s
user    0m0.216s
sys     0m0.076s
```
best C version:
```
real    0m0.135s
user    0m0.132s
sys     0m0.060s
```

Another possibility will be to add a `DoubleEndedIterator::next_two_side()` with a deffault implementation, and specialising it for slices, and use it here (`MutableSlice::reverse()` can then become safe). This benchmark will then be safe.

What do you think?
This is probably faster storing raw pointers:

```rust
struct TwoSidedIterator<'a, T: 'a> {
    start: *mut T,
    end: *mut T,
    _marker: marker::ContravariantLifetime<'a>
}

fn new(x: &'a mut [T]) -> TwoSideIterator<'a, T> {
    TwoSideIterator {
        start: x.as_mut_ptr(),
        end: unsafe {x.as_mut_ptr().offset(x.len() - 1)},
        _marker: marker::ContravariantLifetime
    }
}

fn next(&mut self) -> Option<(&'a mut T, &'a mut T)> {
    if self.start < self.end {
        let ret = unsafe { (&mut *self.start, &mut *self.end) };
        self.start = self.start.offset(1);
        self.end = self.end.offset(-1);
        ret
    } else {
        None
    }
}
```


If not that, decrementing `self.last` instead of doing this subtraction would be better (would avoid the need to store `nb` too).