You can take the cheap and easy way, without a proper parser. The important thing to recognise is that this grammar is actually fairly simple – it has no recursion or such. It is just a flat listing of Strs and Explodes.

The easy way

So we can start by breaking the string down into a list containing the text and the separators as separate values. We need a data type to separate the separators (%%) from actual text (everything else.)

data ParserTokens = Sep | T Text

Breaking it down

Then we need to break the list into its constituents.

tokenise = intersperse Sep . map T . Text.splitOn "%%"

This will first split the string on %%, so in your example it'll become

["The quick brown ","fox"," ","jumps"," over the ","lazy"," dog."]

then we map T over it, to turn it from a [Text] to a [ParserTokens]. Finally, we intersperse Sep over it, to reintroduce the %% separators but in a shape that's easier to deal with. The result is, in your example,

[T "The quick brown ",Sep,T "fox",Sep,T " ",Sep,T "jumps",Sep,T " over the ",Sep,T "lazy",Sep,T " dog."]

Building it up

With this done, all that remains is parsing this thing into the shape you want it. Parsing this amounts to finding the 1-2-3 punch of Sep–T "something"–Sep and replacing it with Explode "something". We write a recursive function to do this.

construct [] = []
construct (T s : rest) = Str s : construct rest
construct (Sep : T s : Sep : rest) = Explode s : construct rest
construct _ = error "Mismatched '%%'!"

This converts T s to Str s and the combination of separators and a T s into an Explode s. If the pattern matching fails, it's because there were a stray separator somewhere, so I've just set it to crash the program. You might want better error handling there – such as wrapping the result in Either String or something similar.

With this done, we can create the function

parseTemplate = construct . tokenise

and in the end, if we run your example through parseTemplate, we get the expected result

[Str "The quick brown ",Explode "fox",Str " ",Explode "jumps",Str " over the ",Explode "lazy",Str " dog."]

For such simple parser even Attoparsec seems to be overkill:

parse = map (\w -> case w of 
              '%':'%':expl -> Explode $ init $ init expl
              str -> Str str) . words

Of course, this code needs some sanity checks for Explode case.

This doesn't handle whitespace the way you specified, but it should get you on the right track.

parseMU = zipWith ($) (cycle [Str,Explode]) . splitps where
  splitps :: String -> [String]
  splitps [] = [[]]
  splitps ('%':'%':r) = [] : splitps r
  splitps (c:r) = let
    (a:r') = splitps r
    in ((c:a):r')