Clojure sum maps with strings and numbers

Solution using generic functions

You could use generic functions - let's call it here o+ (operator +) - by making use of Clojure's multiple dispatch ability. By multiple dispatch you avoid if - else or cond clauses - for distinguishing the argument types/classes - thereby the code stays extensible (further cases can be added without having to change existing code). The function at the end of the defmulti definition is the dispatch function. In the defmethod form - right before the actual function arguments list (vector), you list the dispatch case for which then Clojure looks when deciding which method to use.

(defmulti o+ (fn [& args] (mapv class args)))
(defmethod o+ [Number Number] [x y] (+ x y)) ;; Numbers get added
(defmethod o+ [clojure.lang.PersistentVector clojure.lang.PersistentVector]
  [x y] (into (empty x) (concat x y))) ;; Vectors concatentated
(defmethod o+ [clojure.lang.PersistentArrayMap clojure.lang.PersistentArrayMap] 
  [x y] (merge-with o+ x y)) ;; Maps merged-with #'o+ (recursive definition!)

Test

You can fuse then two maps with the (now recursively defined) o+ operator:

(def map1 {:a {:b 1} :c ["dog"]})
(def map2 {:a {:b 2} :c ["cat"]})

(o+ map1 map2) ;; or originally: (merge-with o+ map1 map2)
;; => {:a {:b 3}, :c ["dog" "cat"]}

Even deeper nested maps are covered

Due to the recursive character of this definition - this works also with more deeply nested maps as long as they have the same structure - and use only the defined class cases (otherwise one could add further cases):

(def mapA {:a {:b 2 :c {:d 1 :e ["a"] :f 3}} :g ["b"]})
(def mapB {:a {:b 3 :c {:d 4 :e ["b" "e"] :f 5}} :g ["c"]})

(o+ mapA mapB)
;;=> {:a {:b 5, :c {:d 5, :e ["a" "b" "e"], :f 8}}, :g ["b" "c"]}

Use reduce to add more maps at once

And as long as you can apply o+ on two objects, you can process an arbitrary number of maps using reduce:

(def mapA {:a {:b 2 :c {:d 1 :e ["a"] :f 3}} :g ["b"]})
(def mapB {:a {:b 3 :c {:d 4 :e ["b" "e"] :f 5}} :g ["c"]})
(def mapC {:a {:b 1 :c {:d 3 :e ["c"] :f 1}} :g ["a"]})

(reduce o+ [mapA mapB mapC]) ;; this vector could contain much more maps!
;; => {:a {:b 6, :c {:d 8, :e ["a" "b" "e" "c"], :f 9}}, :g ["b" "c" "a"]}

;; or we could define in addition:
(defmethod o+ :default [& args] (reduce o+ args))
;; which makes `o+` to a variadic function (function which can be
;; called with as many arguments you want)

;; then, whenever we add more than two arguments, it will be activated:
(o+ mapA mapB mapC)
;; => {:a {:b 6, :c {:d 8, :e ["a" "b" "e" "c"], :f 9}}, :g ["b" "c" "a"]}

;; and this also works:
(o+ 1 2 3 4 5 6)
;; => 21
(o+ ["a"] ["b" "c"] ["d"])
;; => ["a" "b" "c" "d"]

You can use merge-with with a custom function to resolve conflicts when merging maps.

(defn my-merge [a b]
  (merge-with (fn [a b]
                (if (map? a)
                  (merge-with + a b)
                  (into a b)))
              a b))

Or defined recursively:

(defn my-merge [a b]
  (cond (vector? a) (into a b)
        (number? a) (+ a b)
        (map? a)    (merge-with my-merge a b)
        :else       (throw (ex-info "Unsupported values" {:values [a b]}))))

Here's an idea. I didn't test this, and I'm quite sure a more clever solution will come... especially now that I said that this is an answer (the someone-said-something-wrong-on-the-internet effect) :)

(reduce
  (fn [accum item]
    (let [b-accum (get-in accum [:a :b])
          b-item (get-in item [:a :b])
          new-b (+ b-accum b-item)
          new-c (vec (concat (:c accum) (:c item))]
      {:a {:b new-b} :c new-c}))
 [map1 map2])
  

(require '[net.cgrand.xforms :as x])

(let [map1 {:a {:b 1} :c ["dog"]}
      map2 {:a {:b 2} :c ["cat"]}]
        (->> [map1 map2]
            (into {}
                (x/multiplex
                    {:a (comp (map :a) (map :b) (x/reduce +) (x/into [:b]) (x/into {}))
                     :c (comp (mapcat :c) (x/reduce conj))}))))