Simplify watch/ValueChanged/BuildValue

* make BuildValue, TaskResult, ValueChanged into simple JsValue holders so we don't need the type parameter complexity
* we can thus drop `DynamicSerialization` and associated complexity from client side
* we then make `SbtClient.watch[T]` require a static Reads for the watched type so we have compile-time safety that we can deserialize
* if the server-provided value doesn't match the T we wanted to watch, we get a failure result passed to the watch listener
* we keep `SbtClient.rawWatch()` for now because it allows you to get a custom exception type. We can probably do better here, like a `watchWithCustomException[T,E]`.
* ValueChanged, TaskResult, and BuildValue could probably all be collapsed together or at least one of the three eliminated, but haven't done that in this patch; this would also lead to replacing rawWatch with some nicer approach probably.

Most (possibly all) messages go only one direction, but both client and server send stuff and receive stuff. So we could split protocol into client-side and server-side protocol and each would have some Reads and some Writes, in theory. It could be a fair amount of surgery to split up; maybe you'd have to introduce `trait ClientOriginatedMessage` and `trait ServerOriginatedMessage` and then type-parameterize places that use just `Message` now such that when receiving each side uses the opposite trait from when sending. I'd have to play with it to see how annoying it is.