concat() fails when args have sparse.COO data and different fill values

MCVE Code Sample

import numpy as np
import pandas as pd
import sparse
import xarray as xr

# Indices and raw data
foo = [f'foo{i}' for i in range(6)]
bar = [f'bar{i}' for i in range(6)]
raw = np.random.rand(len(foo) // 2, len(bar))

# DataArray
a = xr.DataArray(
    data=sparse.COO.from_numpy(raw),
    coords=[foo[:3], bar],
    dims=['foo', 'bar'])

print(a.data.fill_value)  # 0.0


# Created from a pd.Series
b_series = pd.DataFrame(raw, index=foo[3:], columns=bar) \
             .stack() \
             .rename_axis(index=['foo', 'bar'])
b = xr.DataArray.from_series(b_series, sparse=True)

print(b.data.fill_value)  # nan


# Works despite inconsistent fill-values
a + b
a * b


# Fails: complains about inconsistent fill-values
# xr.concat([a, b], dim='foo')  # ***

# The fill_value argument doesn't help
# xr.concat([a, b], dim='foo', fill_value=np.nan)


def fill_value(da):
    """Try to coerce one argument to a consistent fill-value."""
    return xr.DataArray(
        data=sparse.as_coo(da.data, fill_value=np.nan),
        coords=da.coords,
        dims=da.dims,
        name=da.name,
        attrs=da.attrs,
        )


# Fails: "Cannot provide a fill-value in combination with something that
# already has a fill-value"
# print(xr.concat([a.pipe(fill_value), b], dim='foo'))


# If we cheat by recreating 'a' from scratch, copying the fill value of the
# intended other argument, it works again:
a = xr.DataArray(
    data=sparse.COO.from_numpy(raw, fill_value=b.data.fill_value),
    coords=[foo[:3], bar],
    dims=['foo', 'bar'])
c = xr.concat([a, b], dim='foo')

print(c.data.fill_value)  # nan

# But simple operations again create objects with potentially incompatible
# fill-values
d = c.sum(dim='bar')
print(d.data.fill_value)  # 0.0

Expected

concat() can be used without having to create new objects; i.e. the line marked *** just works.

Problem Description

Some basic xarray manipulations don't work on sparse.COO-backed objects.

xarray should automatically coerce objects into a compatible state, or at least provide users with methods to do so. Behaviour should also be documented, e.g. in this instance, which operations (here, .sum()) modify the underlying storage format in ways that necessitate some kind of (re-)conversion.

Output of xr.show_versions()

Start by reproducing the MCVE at the xr.concat entry point and inspect how sparse.COO fill_value differences are handled. Compare concat with the shown arithmetic operations and the fill_value argument; done means the marked concat call works for these inputs and the resulting fill-value behavior is documented.