Copy every field,  all the time.

This change is for improved performance in typical use cases.
Unfortunately, this is a tradeoff,  and not always a win either

It turns out that `LibPQ.getvalue'` is substantially faster for small
bytestrings than `LibPQ.getvalue`.   Apparently,  this is due to the
fact that `getvalue'` (indirectly) calls `mallocForeignPtrBytes`,  which
is "heavily optimized",  whereas `getvalue` calls `newForeignPtr` and
sets up a finalizer that touches the  `LibPQ.Result` to prevent it from
being freed by GHC's garbage collector.

Presumably,  there is a point at which `getvalue` becomes faster than
`getvalue'`,  as the former should be O(1) whereas the latter is `O(n)` due
to memcpy.   However,  for common use cases this is a moot point,
as postgresql-simple does a memcpy upon conversion to a `ByteString`
anyway.

The other conversions don't copy the memory,  but most types are
guaranteed to be short enough that this switch is a win.   The only
pre-packaged conversions where this change is a loss is when dealing
with big arrays,  big hstores,  and big json documents.   Just how big
where the crossover point is needs to be researched.
Add FromField instances for IORefs and MVars
Add PGArray Type

Credit to Joey Adams;  closes #50