stub: Use named classes rather than anonymous in ServerCalls

This has a number of small benefits.  First, it makes stack traces
easier to read.  For example:

Old class names:
```
ServerCalls$1$1.class
ServerCalls$1.class
ServerCalls$2$1.class
ServerCalls$2.class
```

New class names:
```
ServerCalls$StreamingServerCallHandler.class
ServerCalls$StreamingServerCallHandler$StreamingServerCallListener.class
ServerCalls$UnaryServerCallHandler.class
ServerCalls$UnaryServerCallHandler$UnaryServerCallListener.class
```

This is much easier to read quickly, espcially if line numbers don't
match between HEAD and the code that prints the stack trace.

Another benefit of this is that it drops a class file from the jar
(`EmptyServerCallListener`).

Lastly, it makes it easier in the future to test, since the specific
class can be referenced from a test.  Traditionally this class
hasn't been easy to test.

stub/src/main/java/io/grpc/stub/ServerCalls.java

@@ -104,30 +104,44 @@ public final class ServerCalls {
       extends StreamingRequestMethod<ReqT, RespT> {
   }
 
-  /**
-   * Creates a {@code ServerCallHandler} for a unary request call method of the service.
-   *
-   * @param method an adaptor to the actual method on the service implementation.
-   */
-  private static <ReqT, RespT> ServerCallHandler<ReqT, RespT> asyncUnaryRequestCall(
-      final UnaryRequestMethod<ReqT, RespT> method) {
-    return new ServerCallHandler<ReqT, RespT>() {
+  private static final class UnaryServerCallHandler<ReqT, RespT>
+      implements ServerCallHandler<ReqT, RespT> {
+
+    private final UnaryRequestMethod<ReqT, RespT> method;
+
+    // Non private to avoid synthetic class
+    UnaryServerCallHandler(UnaryRequestMethod<ReqT, RespT> method) {
+      this.method = method;
+    }
+
     @Override
-      public ServerCall.Listener<ReqT> startCall(
-          final ServerCall<ReqT, RespT> call,
-          Metadata headers) {
+    public ServerCall.Listener<ReqT> startCall(ServerCall<ReqT, RespT> call, Metadata headers) {
       Preconditions.checkArgument(
           call.getMethodDescriptor().getType().clientSendsOneMessage(),
           "asyncUnaryRequestCall is only for clientSendsOneMessage methods");
-        final ServerCallStreamObserverImpl<ReqT, RespT> responseObserver =
+      ServerCallStreamObserverImpl<ReqT, RespT> responseObserver =
           new ServerCallStreamObserverImpl<ReqT, RespT>(call);
       // We expect only 1 request, but we ask for 2 requests here so that if a misbehaving client
       // sends more than 1 requests, ServerCall will catch it. Note that disabling auto
       // inbound flow control has no effect on unary calls.
       call.request(2);
-        return new EmptyServerCallListener<ReqT>() {
-          boolean canInvoke = true;
-          ReqT request;
+      return new UnaryServerCallListener(responseObserver, call);
+    }
+
+    private final class UnaryServerCallListener extends ServerCall.Listener<ReqT> {
+      private final ServerCall<ReqT, RespT> call;
+      private final ServerCallStreamObserverImpl<ReqT, RespT> responseObserver;
+      private boolean canInvoke = true;
+      private ReqT request;
+
+      // Non private to avoid synthetic class
+      UnaryServerCallListener(
+          ServerCallStreamObserverImpl<ReqT, RespT> responseObserver,
+          ServerCall<ReqT, RespT> call) {
+        this.call = call;
+        this.responseObserver = responseObserver;
+      }
+
       @Override
       public void onMessage(ReqT request) {
         if (this.request != null) {
@@ -180,32 +194,57 @@ public final class ServerCalls {
           responseObserver.onReadyHandler.run();
         }
       }
-        };
     }
-    };
   }
 
   /**
-   * Creates a {@code ServerCallHandler} for a streaming request call method of the service.
+   * Creates a {@code ServerCallHandler} for a unary request call method of the service.
    *
    * @param method an adaptor to the actual method on the service implementation.
    */
-  private static <ReqT, RespT> ServerCallHandler<ReqT, RespT> asyncStreamingRequestCall(
-      final StreamingRequestMethod<ReqT, RespT> method) {
-    return new ServerCallHandler<ReqT, RespT>() {
+  private static <ReqT, RespT> ServerCallHandler<ReqT, RespT> asyncUnaryRequestCall(
+      UnaryRequestMethod<ReqT, RespT> method) {
+    return new UnaryServerCallHandler<ReqT, RespT>(method);
+  }
+
+  private static final class StreamingServerCallHandler<ReqT, RespT>
+      implements ServerCallHandler<ReqT, RespT> {
+
+    private final StreamingRequestMethod<ReqT, RespT> method;
+
+    // Non private to avoid synthetic class
+    StreamingServerCallHandler(StreamingRequestMethod<ReqT, RespT> method) {
+      this.method = method;
+    }
+
     @Override
-      public ServerCall.Listener<ReqT> startCall(
-          final ServerCall<ReqT, RespT> call,
-          Metadata headers) {
-        final ServerCallStreamObserverImpl<ReqT, RespT> responseObserver =
+    public ServerCall.Listener<ReqT> startCall(ServerCall<ReqT, RespT> call, Metadata headers) {
+      ServerCallStreamObserverImpl<ReqT, RespT> responseObserver =
           new ServerCallStreamObserverImpl<ReqT, RespT>(call);
-        final StreamObserver<ReqT> requestObserver = method.invoke(responseObserver);
+      StreamObserver<ReqT> requestObserver = method.invoke(responseObserver);
       responseObserver.freeze();
       if (responseObserver.autoFlowControlEnabled) {
         call.request(1);
       }
-        return new EmptyServerCallListener<ReqT>() {
-          boolean halfClosed = false;
+      return new StreamingServerCallListener(requestObserver, responseObserver, call);
+    }
+
+    private final class StreamingServerCallListener extends ServerCall.Listener<ReqT> {
+
+      private final StreamObserver<ReqT> requestObserver;
+      private final ServerCallStreamObserverImpl<ReqT, RespT> responseObserver;
+      private final ServerCall<ReqT, RespT> call;
+      private boolean halfClosed = false;
+
+      // Non private to avoid synthetic class
+      StreamingServerCallListener(
+          StreamObserver<ReqT> requestObserver,
+          ServerCallStreamObserverImpl<ReqT, RespT> responseObserver,
+          ServerCall<ReqT, RespT> call) {
+        this.requestObserver = requestObserver;
+        this.responseObserver = responseObserver;
+        this.call = call;
+      }
 
       @Override
       public void onMessage(ReqT request) {
@@ -240,9 +279,17 @@ public final class ServerCalls {
           responseObserver.onReadyHandler.run();
         }
       }
-        };
     }
-    };
+  }
+
+  /**
+   * Creates a {@code ServerCallHandler} for a streaming request call method of the service.
+   *
+   * @param method an adaptor to the actual method on the service implementation.
+   */
+  private static <ReqT, RespT> ServerCallHandler<ReqT, RespT> asyncStreamingRequestCall(
+      StreamingRequestMethod<ReqT, RespT> method) {
+    return new StreamingServerCallHandler<ReqT, RespT>(method);
   }
 
   private static interface UnaryRequestMethod<ReqT, RespT> {
@@ -263,6 +310,7 @@ public final class ServerCalls {
     private Runnable onReadyHandler;
     private Runnable onCancelHandler;
 
+    // Non private to avoid synthetic class
     ServerCallStreamObserverImpl(ServerCall<ReqT, RespT> call) {
       this.call = call;
     }
@@ -352,24 +400,6 @@ public final class ServerCalls {
     }
   }
 
-  private static class EmptyServerCallListener<ReqT> extends ServerCall.Listener<ReqT> {
-    @Override
-    public void onMessage(ReqT request) {
-    }
-
-    @Override
-    public void onHalfClose() {
-    }
-
-    @Override
-    public void onCancel() {
-    }
-
-    @Override
-    public void onComplete() {
-    }
-  }
-
   /**
    * Sets unimplemented status for method on given response stream for unary call.
    *