Fixed last TypedList-related FIXME item in experimental.

The fix was relatively tricky.

The failing test was test_IterablePayloadExpression__callbacks_10().

Here's the body of the test:

    score_template = scoretemplatetools.GroupedRhythmicStavesScoreTemplate(
        staff_count=1)
    score_specification = musicexpressiontools.ScoreSpecificationInterface(
        score_template)
    material_manager = musicexpressiontools.MaterialManager()
    red_segment = score_specification.append_segment(name='red')
    red_segment.set_time_signatures(3 * [(3, 8)])
    divisions = material_manager.register_material(
        [(1, 16), (2, 16), (3, 16), (4, 16)])
    timespan = timespantools.Timespan(Offset(2, 16), Offset(10, 16))
    divisions = divisions & timespan
    red_segment.set_divisions(divisions)
    red_segment.set_rhythm(library.sixteenths)
    score = score_specification.interpret()

The test was blowing up at interpretation (ie, the last line shown above).

Why was interpretation blowing up?

The call to red_segment.set_divisions(divisions) was behaving incorrectly
after rewiring TypedList. Recall that TimespanInventory inherits from
TypedList. This means that TimespanInventory previously inherited from built-in
list but no longer inherits from built-in list. This means that instance tests
like this ...

    isinstance(timespan_inventory, list)

... passed back when TimespanInventory inherited from list but no longer pass.
A number of such instance tests were changed during TypedList integration to be
something like ...

    isinstance(timespan_inventory, (list, datastructuretools.TypedList))

... instead. This is good. But a couple of these instance tests were
(understandably) not ported forward. And it was in fact one of these old-style
instance tests that was causing test_IterablePayloadExpression__callbacks_10()
to fail. The relevant code is in the implementation of _all_are_expressions in
SetMethodMixin.

OLD:

    def _all_are_expressions(self, expr):
        from experimental.tools import musicexpressiontools
        if isinstance(expr, (tuple, list)): # <== this is the line in question
            if all(
                isinstance(x, musicexpressiontools.Expression)
                for x in expr
                ):
                return True
        return False

NEW:

    def _all_are_expressions(self, expr):
        from experimental.tools import musicexpressiontools
        if isinstance(expr, (tuple, list, datastructuretools.TypedList)):
            if all(
                isinstance(x, musicexpressiontools.Expression)
                for x in expr
                ):
                return True
        return False

This, in turn, caused SetMethodMixin._expr_to_expression() to misbehave:

    def _expr_to_expression(self, expr):
        from abjad.tools import rhythmmakertools
        from experimental.tools import musicexpressiontools
        if isinstance(expr, musicexpressiontools.Expression):
            return expr

        # should test true on the following condition
        elif self._all_are_expressions(expr):
            return musicexpressiontools.ExpressionInventory(expr)

        # but was testing true here instead
        elif isinstance(expr,
            (tuple, list, datastructuretools.TypedList)):
            return musicexpressiontools.IterablePayloadExpression(expr)

        elif isinstance(expr, (str)):
            component = functiontools.parse(expr)
            return musicexpressiontools.StartPositionedRhythmPayloadExpression(
                [component], start_offset=0)
        elif isinstance(expr, rhythmmakertools.RhythmMaker):
            return musicexpressiontools.RhythmMakerExpression(expr)
        else:
            message = 'do not know how to change {!r} to expression.'
            raise TypeError(message.format(expr))

This is particularly evil because SetMethodMixin._expr_to_expression() wasn't
failing. It was instead simply treating input incorrectly, which caused failure
later during interpretation.

NOTE: the message ...

    py.test.skip('FIXME: Broke after TypedList stopped inheriting from list.')

... was absolutely essentially for making this fix.

MILESTONE: all migration-related FIXME items in experimental have been
resolved.

We are now back to where we were prior to migration everywhere in the codebase
(both in mainline and experimental).