types and parsers for epoch time and absolute DateTime

dependent types and mandating exactly 0 or 1 Some values is overkill.

`xs :: List[Option[DateTime]]` is exactly the right type.

in haskell we'd use the First monoid instance on Maybe. it's like short circuit boolean `or`, which returns the leftmost true. namely, in the case of First, `mappend` returns the leftmost Just x. see http://hackage.haskell.org/package/base-4.7.0.1/docs/Data-Monoid.html#t:First

I can replace the code in parseAtTime by `mconcat xs` where `xs :: List[First[DateTime]]`.  this should eliminate any doubts about how many successful parses there are. here's how I got First to work in scalaz:


```scala
// scalac needed help with type inference, I guess.
def f[A](x: Option[A]): scalaz.@@[Option[A],scalaz.Tags.First] =
  if (x.isDefined) Tags.First(x)
  else Tags.First(none[A])

val xs = (1 |-> 10).map({x:Int => if (x % 3 == 0) "divisible by 3".some else none })
// List[Option[String]] = List(None, None, Some(divisible by 3), None, None, Some(divisible by 3), None, None, Some(divisible by 3), None)

def mconcat[A: Monoid](xs: Seq[A]): A = xs.foldRight(Monoid[A].zero)(_ |+| _)

mconcat(xs.map(f)) // res40: scalaz.@@[Option[String],scalaz.Tags.First] = Some(divisible by 3)
```