kite: implement Pre and Post middleware chaining

This PR enables us to chain global and method based handlers with existing methods. There are two main kite methods, which are globablly invoked. That means any handler added here is going to be executed whatever a request comes regardless the method name. The api is in the form of:

```go
// PreHandle registers an handler which is executed before a kite.Handler
// method is executed. Calling PreHandle multiple times registers multiple
// handlers. The execution order is FIFO.
func (k *Kite) PreHandle(handler Handler)  {}
func (k *Kite) PreHandleFunc(handler HandlerFunc) { }

// PostHandle registers an handler which is executed after a kite.Handler
// method is executed. Calling PostHandler multiple times registers multiple
// handlers. The execution order is FIFO.
func (k *Kite) PostHandle(handler Handler) {}
func (k *Kite) PostHandleFunc(handler HandlerFunc) { }
```

This is useful for application based throttling, logging or any other specific task that needs to be done for all methods.

One has also the ability to add handlers for individual methods:

```go
// PreHandler adds a new kite handler which is executed before the method.
func (m *Method) PreHandle(handler Handler) *Method { }
func (m *Method) PreHandleFunc(handler HandlerFunc) *Method { }


// PostHandle adds a new kite handler which is executed after the method.
func (m *Method) PostHandle(handler Handler) *Method { }
func (m *Method) PostHandleFunc(handler HandlerFunc) *Method { }
```

And example usage for a method called `foo` is:

```go
k.HandleFunc("foo", Square).PreHandleFunc(func(r *kite.Request) (interface{}, error) {
	fmt.Println("This pre handler is only valid for this individual method")
	return nil, nil
})
```