Server/grpc package organisation

Hey guys, I would like to suggest a simpler organisation of the server/grpc package.

So currently, we have:

- server
  - grpc
    - core
    - service
  - server.go

server.go contains the initialization of the gRPC server and the register function that assign the different gRPC service implementation to the server itself.
core and service folders each contains one file with a struct that implement the corresponding generated gRPC interface.

My suggestion is to add new grpc services in new files directly in the grpc folder/package.
Each grpc service will have a dedicated struct (like currently) with its own dependency (could be to sdk or to a sub package for sdk).
The filename will be the same as the gRPC service (eg: execution) and the struct will be suffixed by Server (like the generated gRPC interface to implement).

So the folder will look like:

- server
  - grpc
    execution.go
    service.go
    instance.go
    server.go

and for example the content of execution.go will look like:

package grpc

type ExecutionServer struct {
	sdk *sdk.SDK
}

func NewExecutionServer(sdk *sdk.SDK) *ExecutionServer {
	return &ExecutionServer{sdk: sdk}
}

func (s *ExecutionServer) Create(context context.Context, request ....) (*serviceapi.EmitEventReply, error) {
	......
}

The register function in server.go will look like:

func (s *Server) register() error {
	executionServer := NewExecutionServer(s.sdk)
	// same for all grpc service

	api.RegisterExecutionServer(s.instance, executionServer)
	// same for all grpc service

	reflection.Register(s.instance)
	return nil
}

@core what are you feedbacks?