Add ":base" and ":merge-with" support for resources

### What?

This pull request lets liberator users define maps of "base" resource behaviors; other resources can inherit from these and share keys.  For example:

```clojure
(def base-resource
  {:handle-not-acceptable "That just wasn't acceptable!"
   :handle-created "You created something."})

(defresource my-resource
  :base base-resource
  :handle-ok "All's well.")
```

Expands out to this before compilation:

```clojure
(defresource my-resource
  :handle-not-acceptable "That just wasn't acceptable!"
  :handle-created "You created something."
  :handle-ok "All's well.")
```

These base resources can stack nicely, as the tests show. The base maps will unfold from an arbitrary nesting depth.

You can also specify a `:merge-with` entry that shows how to combine clashes in keys. (by default, the new replaces the entry in the base.)

For example, the following resource will try to handle the not acceptable path, but delegate to its parent if the handler returns nil or false. This particular example only overrides a json response, but allows the parent to handle everything else (predefined HTML, for example.)

```clojure
(def base-on-falsey
  (fn [l r] (some-fn r l)))

(defresource my-resource
  :base base-resource
  :merge-with {:handle-not-acceptable base-on-falsey}
  :handle-not-acceptable (media-typed
                          {"application/json"
                           {:success false
                            :message "No acceptable resource available"}})
  :handle-ok "All's well.")
```

(`media-typed` is another function I wrote, similar to `by-method`, that delegates on content type.)

### Why?

I'm using this in the https://paddleguru.com codebase to define default `:handle-not-acceptable` and `:handle-not-found` returns:

```clojure
(def guru-base
  "Base for all guru resources.

   Due to the way liberator's resources merge, these base definitions
   define a bunch of content types, even if the resources that inherit
   from them don't. The defaults are here to provide reasonable text
   error messages, instead of returning big slugs of html."
  (let [not-found (comp rep/ring-response
                        (route/not-found shared/status-404-page))
        base {"text/html" not-found}]
    {:handle-not-acceptable
     (->> {"application/json" {:success false
                               :message "No acceptable resource available"}
           "text/plain" "No acceptable resource available."}
          (with-default "text/plain")
          (media-typed base))

     :handle-not-found
     (->> {"application/json" {:success false
                               :message "Resource not found."}
           "text/plain" "Resource not found."}
          (with-default "text/plain")
          (media-typed base))}))
```

The HUGE benefit I gained from this inheritance was the ability to declare protected or authenticated resources using @cemerick's [Friend](https://github.com/cemerick/friend) library. Friend controls the `authorized?` and `handle-unauthorized` decision points; if the user isn't logged in, Friend pulls the user out of the decision tree, attempts authentication, and then - this is the cool part - injects the user back in to the liberator tree at the next decision point.

```clojure
(def friend-resource
  "Base resource that will handle authentication via friend's
  mechanisms. Provide an authorization function and you'll be good to
  go."
  {:base guru-base
   :handle-unauthorized
   (media-typed {"text/html" (fn [req]
                               (friend/unauthorized!
                                (-> req :resource :allowed?)
                                req))
                 "application/json"
                 {:success false
                  :message "Not authorized, visit /login"}
                 :default (constantly "Not authorized.")})})
```

That call to `friend/unauthorized!` signals Friend to pick up at the `allowed?` decision point once the user authenticates, only if authorizations passes.

Hope you guys find this useful! I've included midje tests for my merging, but wasn't sure how to convert the above examples into tests in your current framework.