Added request counter to Paginator

Added instrumentation for Paginator so API clients can understand the number of requests executed per search.
If someone reuses the same Paginator instance on multiple calls to .search(), then we will just continue to accumulate this counter. Is this the intended behavior, or do you want to know the number of successful request per call to .search()?

It is possible to compute this number without any modifications to Paginator. Isn't it just the number of objects that you consume from the stream of results integer-divided by the page size? Another approach would be to create a custom Paginator.Callback implementation that counts the number of results from the stream consumed. Once its done, you can infer the number of successful requests by dividing by the page size:

public abstract class CountingCallback<E, F>
    implements Paginator.Callback<E, CountingCallback.Count<F>> {

  public static class Count<F> {

    private final int[] countPtr;
    private final F value;

    Count(int[] countPtr, F value) {
      this.countPtr = countPtr;
      this.value = value;
    }

    public int count() {
      return countPtr[0]; // dereference the pointer
    }

    public F value() {
      return value;
    }
  }

  @Override public final Count<F> consumeResponses(final Iterable<E> responses)
      throws IOException {
    final int[] countPtr = {0}; // An ugly hack to emulate a pointer to an int
    return new Count<F>(countPtr, countResponses(
        new Iterable<E>() {

          private final Iterator<E> delegate = responses.iterator();

          @Override public Iterator<E> iterator() {
            return new AbstractIterator<E>() {
                  @Override protected E computeNext() {
                    if (delegate.hasNext()) {
                      ++countPtr[0]; // dereference and increment
                      return delegate.next();
                    }
                    return endOfData();
                  }
                };
          }
        }));
  }

  public abstract F countResponses(Iterable<E> responses) throws IOException;
}

I know it is a little more complicated, but it has the advantage of not requiring any modifications to Paginator. I'd like to not allow too many features to creep into this code and keep its purpose really tightly defined, but please do push back and tell me if you think i'm crazy if you disagree. :-)