Add function on EitherAssert for chaining Left and Right into Non Empty Lists

While converting some more tests, I encountered another use case that feels like it could be a bit more accessible.

When you have code that uses NonEmptyLists inside Eithers, it's not terribly idiomatic to get them out in order to assert on them. For example
```
fun returnsNel(): Either, Int> {
return nonEmptyListOf("error", "other error")
}

@Test
fun assertOverLeftNel() {
val result = returnsNel()

// either assert
assertThat(result).isLeft()
val unwrappedResult = result.leftOrNull()!!

// non empty list assert
assertThat(unwrappedResult).contains("error", "other error")
}
```

either assert asLeft / containsLeftInstanceOf will give you an object assertion for the NonEmptyList, but there's no easy way to get to the underlying object in order to begin a NonEmptyList assertion. If you just want to do an assertion on the full list using equality you can do a `assertThat(result).containsOnLeft(nonEmptyListOf("error", "other error")` - but that's it, we're missing many of the other tools for NonEmptyList asserts such as just matching one element, matching on some elements, checking for sorting. I think combining Eithers/raises that then contain NonEmptyLists on the left side is a particularly common usecase in Arrow, see aliases such as EitherNel, and functions like bindNel

This is sort of also a limitation on the base library, as there's not really a super easy way to extract out a property of a complex object and get to its relevant special case assertions, however in practice I think this is particularly a bit more of pain here due to the ubiquitously wrapped nature of Eithers, that try to enforce safety.

I can think of two possible solutions for this, one would be to offer some shortcuts into the special case assertions, something like a `asLeftNel()` and `asRightNel()` option that would verify the Either had the appropriate side, was of type NonEmptyList, and launch right into the NonEmptyList assertions. So that would be used something like `assertThat(result).asLeftNel().isSorted()`

The other option would be a value that allows for assigning from an asLeft or asRight call. This could be a new method, like `asLeftValue()`, or an extension property on AbstractObjectAssertion like `.value`

I haven't directly encountered this for Raise, but given the Raise works with all the same orAccumulate patterns, I think it likely makes sense to complete a similar solution there.

At first blush I think I might lean towards the special case for NonEmptyLists of `asLeftNel()` - but would be open to input on what you think might make the most sense. I'm happy to work towards an implementation if this makes sense to you. Thanks!

Start by reading the existing EitherAssert and NonEmptyList assertion APIs, then compare the proposed asLeftNel()/asRightNel() shortcuts with the alternative value-extraction approach. Check whether a similar solution is needed for Raise and define focused assertions covering the requested Either and NonEmptyList use cases; the issue needs a design decision before implementation.

Vom Indexierungsmodell aus dem Issue-Text verfasst.