Improved copy methods

The new copy methods have a uniform API (which also matches pandas): they take
a keyword argument `deep`.

`deep=False` no longer always loads data into a numpy array. This makes it
possible to write functions to using the public API to rename variable
dimensions without always loading variables into memory.
Improved __repr__/__str__ for xray objects

The new `__repr__` for xray.Dataset is inspired by the representation
for iris.Cube:

    <xray.Dataset>
    Coordinates:     (time: 20, dim1: 100, dim2: 50, dim3: 10)
    Non-coordinates:
        var1              -         X          X         -
        var2              -         X          X         -
        var3              -         X          -         X
    Attributes:
        Empty

The new `__repr__` for xray.XArray and xray.DatasetArray shows the actual data
as summarized by `repr(array.data)`, as long as the data is an ndarray or
has fewer than 10^5 elements (~400 KB):

    <xray.DatasetArray 'my_variable' (time: 2, x: 3)>
    array([[1, 2, 3],
           [4, 5, 6]])
    Attributes:
        foo: bar

`__repr__` not showing the data was a complaint I heard about the prior
representation.

I removed the separate `__str__` implementation so we can have one canonical
string representation (both implementations showed equivalent information).

I am definitely open to suggestions for improving either of these!
Allow Dataset.concat to take a str for concat_over

This is a simple fix for an issue that Holly encountered.
More flexible math with variables from different datasets

PR #33 was definitely a useful change -- item access via [] should return
items still in the context of the dataset they were pulled from.

However, it doesn't make sense to always keep track of all dataset variables.
A particular example is when doing math between variables from different
datasets.

To be more concrete, suppose I have two datasets ("obs" and "sim"), each with
two measurement variables ("tmin" and "tmax"). It should be possible to
calculate `obs['tmin'] - sim['tmin']` without a merge conflict due to
conflicting values of "tmax". Unfortunately, this is exactly what the current
version of xray reports.

This PR fixes this behavior, by automatically including only coordinates
necessary to describe the arrays involved (via `DatasetArray.select`) when
merging datasets resulting from mathematical operations.

A possible downside is that occasionally auxiliary coordinates worth keeping
around will be lost (e.g., `(2 * obs['tmin']).dataset` no longer contains a
variable "tmax"). But on the whole I think this behavior is much more in line
with reasonable expectations.

This change also removes the DatasetArray methods `refocus` and `unselected`
from the public API. I think this is the right call, since these functions
were highly specific and really only useful for the prior version of the
internal API.
Select dataset arrays before merging via dataset[key] = value

It did not really make sense that adding a dataset array to another dataset
with `Dataset.__setitem__` by default merged all dataset variables. With this
commit, set item only merges `dataset_array.select().dataset` (e.g., the array
variable itself and any coordinates). If you really want to merge in the full
dataset associated with a dataset array, there is still `Dataset.merge`, but I
expect this behavior will be less surprising.
Fix typo in XArray.in_memory
Dataset.merge ignores conflicting variable attributes

This is meant as a temporary fix until we figure out the right logic --
note the comments in the docs to this effect.
Use exact array_equal for dtype=object in xarray_equal
Dataset.reindex_like and DatasetArray.reindex_like

This provides an interface for re-indexing a dataset or dataset array using
the coordinates from another object. Missing values along any coordinate are
replaced by `NaN`.

This method is directly based on the pandas method `DataFrame.reindex_like`
(and the related series and panel variants). Eventually, I would like to build
upon this functionality to add a `join` method to `xray.align` with the
possible values `{'outer', 'inner', 'left', 'right'}`, just like
`DataFrame.align`.

This PR depends on PR #71, since I use its improved `copy` method for
datasets.
Resolve merge conflict with dictionary reorder
Refactored Dataset.reindex and generalized xray.align

The new xray.align can handle an arbitrary number of arguments, as well as
four different join options copied from `pandas.DataFrame.align` ('inner',
'outer', 'left' and 'right').

This gives us most of what we need to flip a switch and start automatically
aligning dataset arrays when they are used in mathematical operations. We'll
need to decide if we want to default to outer joins (like pandas) or inner
joins (which are less likely to blow up due to lack of memory or CPU).