Yes, it does. The entire reason it does not maintain order today is because it uses Map :). If I change it to map in this location, it yields:
```
[error] playframework/framework/src/play/src/main/scala/play/api/mvc/ContentTypes.scala:566: type mismatch;
[error]  found   : Map[String,Seq[String]]
[error]  required: scala.collection.immutable.ListMap[String,Seq[String]]
[error]           urlFormEncoded(request).map(_.right.map(d => AnyContentAsFormUrlEncoded(d)))
[error]                                                                                   ^
```
The reason is that the call to urlFormEncoded cascades all the way up to this function:
```
    def tolerantFormUrlEncoded(maxLength: Int): BodyParser[ListMap[String, Seq[String]]] =
      tolerantBodyParser("urlFormEncoded", maxLength, "Error parsing application/x-www-form-urlencoded") { (request, bytes) =>
        import play.core.parsers._
        FormUrlEncodedParser.parse(new String(bytes, request.charset.getOrElse("utf-8")),
          request.charset.getOrElse("utf-8"))
      }
```

Which is the one that actually calls the order-preserving version of FormUrlEncodedParser.parse which must return a ListMap. I've looked at ways to create a Map that preserve's order, but it just doesn't as the internal representation choices are HashMap and TreeMap. Both of those, unlike ListMap, do not preserve insertion order. 

If you're concerned about performance of a List-based map, please note that because the general use of this content type is form parameters, the likely cardinality of the list is relatively low, probably < 100 in >99% of cases (I'm guessing, but hopefully you get my point).  

The only other thing I can think of is to have TWO versions of urlFormEncoded stuff, both order preserving and not. I actually started out that way but the change got to be combinatorially too large. You wouldn't have wanted to review it :)

The API impact of changing it from Map to ListMap within Play is very small and already covered in this patch. The change to users is only going to be noticed if they did something like:
```
val myFormData : Map[String,Seq[String]] = MyContent.asFormUrlEncoded.get
```
instead of:
```
val myFormData = MyContent.asFormUrlEncoded.get
```
Since the fix is relatively easy (drop the explicit type declaration!), I figure this is pretty safe, API wise, albeit not perfect.