Is this Scala/Akka idiomatic and correct for Akka 2.1?
I'm not an akka expert but I did used akka in a project so these are just some of my observations:


result is blocking.

val result = Await.result(master ? Run, timeout.duration)


On case the master takes longer due to load or whatever, the pending result will
exceed the timeout. Try async ask directly. 

val result ask(actor, msg).mapTo[String]

In order to remain async you may carry on with an onComplete as
Future callback:

result onComplete {
    case Success(result) =&gt; doSomethingOnSuccess(result)
    case Failure(failure) =&gt; doSomethingOnFailure(failure)
}


In this case no operation ever blocks the running thread. Read the Akka docs for more details 



  And is there a better approach to waiting for a result from an
  optionally distributed parallel reduction of a collection? In other
  words, is this an Akka equivalent of
  collection.par.map(work).par.reduce(result) or is there a better way?


Operating on distributed data-sets is much better done on an in-memory data processing engine. Using the distributed word count as example, in Spark you do:   

   file.flatMap(line =&gt; line.split(" "))
    .map(word =&gt; (word, 1))
    .reduceByKey(_ + _) 


Actors are made for message processing such as Twitter or WhatsApp but for  computing tasks that must be fast, you use either MapReduce (Hadoop) for offline crunching of Spark/Storm for real-time processing.  Hope that answers your question.