anchor.diff:  
   When a required attribute is not present in the current entity, `Connect` will look for resolvers that can fetch it,
   analyze their inputs, and recursively walk backwards towards the "known data" in the context.
  -This is what makes `Connect` powerful: by leveraging the index containing the attribute relationships you can focus on
  -writing just the primary `edges` of the graph, and then all possible paths can be walked automatically. You can read
  -more about how this works in the Index page.
  -
  -In case the path is a dead end (not enough data), `Connect` triggers an error explaining the miss. Let's see that in action:
  -
  -```clojure
  -(parser {} [:product/brand])
  -; CompilerException clojure.lang.ExceptionInfo: "Insufficient resolver output" {::pp/response-value {...} :key :attribute}
  -```
  -
  -As you can see, `Connect` will fire an error in case your query asks for something and it's not possible to get there.
  +When a required attribute is not present in the current entity, `Connect` will calculate the possibole paths
  +from the data you have to the data you request, then it can use some euristic to decide which path to take
  +and walk this path to reach the data, if there is no possible path connect reader will return `::p/continue` to
  +let another reader try to handle that key. You can read more about how this works in the Index page.
   
   Also remember that single-input resolvers can handle ident-based queries.
   Thus, the following ident-join queries already work without having to define anything else:
  
positive.code: ...
  
  (def my-plugin-with-resolvers
   {::pc/resolvers [some-resolver send-message-mutation]})
  
  (def parser
    (p/parser {::p/env          (fn [env]
                                  (merge
                                    {::p/reader             [p/map-reader pc/reader pc/open-ident-reader]
                                     ::pc/resolver-dispatch resolver-fn
                                     ::pc/mutate-dispatch   mutation-fn
                                     ::pc/indexes           @indexes}
                                    env))
               ::pc/defresolver defresolver
               ::pc/defmutation defmutation
               ::p/mutate       pc/mutate-async
               ::p/plugins      [pc/connect-plugin ; make sure connect-plugin is here, it's order doesn't matter
                                 my-plugin-with-resolvers]}))
  ----
  
  And that's it, the resolvers will be registered right after the parser is defined.
  
negative.code: query actually asks for those properties:
  
  ```
  (pc/defresolver person-resolver [{:keys [database] :as env} {:keys [person/id]}]
    {::pc/input #{:person/id}
     ::pc/output [:person/first-name :person/last-name :person/age]}
    (let [{:keys [age first-name last-name]} (my-database/get-person database id)]
      {:person/age        age
       :person/first-name first-name
       :person/last-name  last-name}))
  
  (pc/defresolver person-name-resolver [_ {:person/keys [first-name last-name]}]
    {::pc/input #{:person/first-name :person/last-name}
     ::pc/output [:person/full-name]}
    {:person/full-name (str first-name " " last-name)})
  ```
  
  This combination of resolvers can still resolve all of the properties in `[:person/full-name :person/age]` (if
  