Idiomatic input parsing in clojure
I think your main problem is that you're using iterate where partitioning and mapping would work just fine.

I would create a simple helper function that splits the input line-seq into cases. Normally you could use partition for this, but since the number of lines can vary from case to case, you would have to use loop/recur. (See my split-cases function below. Also, note that we don't really care about the number of cases on the first line; we completely ignore it via destructuring.)

Now, believe it or not, all you have to do is map your parse-grid function over the result of (split-cases ...) and you'll end up with a list of sets of coordinates, one for each case. 

I think your parse-grid function is very nice. It's concise and it makes good use of map-indexed and destructuring. The only thing I would tweak is that I would leverage the built-in :when syntax of Clojure's for macro to filter out the coordinates of the non-# characters. Then you can take out the filter identity part because there are no longer any nil values to remove.

So, here is how I would revise your code:

(defn split-cases [[_ &amp; lines]]
  "Returns a seq of cases, each of which is a seq of #/. lines."
  (loop [result []
         [number-of-lines &amp; lines] lines]
    (if (seq lines)
      (recur (conj result (take number-of-lines lines))
             (drop number-of-lines lines))
      result)))

(defn parse-grid [grid]
  "Parses a text grid of .s and #s and returns a set of coord
   pairs for each # element"
  (set (for [[row line] (map-indexed vector grid)
             [col c]    (map-indexed vector line)]
             :when (= c \#)]
         [row col])))

(defn read-stdin [] 
  (line-seq (java.io.BufferedReader. *in*)))

(defn parse-cases-stdin []
  (map parse-grid (split-cases (read-stdin))))