Remove downcasting and use explicit errors

[dignifiedquire]

• This removes all downcast_ functionality, replacing it with explicit errors wherever possible. (*)
• For adding error context, there is now .context and .with_context on Result<T, ActorError>, such that this can be preserved
• anyhow is not used anymore, except for testing (*)
• The matching of error to exit code is now mostly done in the From implementations for ActorError, or at the very source inside actors where an error is first encountered that is not an ActorError.

(*) Except in the Runtime which will go away once proper Runtime errors are introduced.

• Depends on Use concrete error types for ipld/* and shared ref-fvm#463

[dignifiedquire]

TODO: undo once a new release with the changes are cut for ref-fvm

[anorth]

This is a much better way of doing things, but it changes some behaviour. We need to trade-off consistency with the old/Go code with this better way of doing things. The unit tests are going to catch some of the inconsistencies as the tests are ported from Go. But they won't cover all cases. I think resolving this is the big question here. It will be much simpler to ensure alignment if the adapting to a concrete exit code is generally done higher up in the call stack, in line with the Go code (and the old downcast calls).

I'm not so sure about pushing ActorError down into structures like the bitfield queue. This queue is a pure data structure, an interpretation of an AMT. Most of the possible exit codes don't make sense there – they're addressed at application level. The Go code makes no use of xc to set exit codes. I would probably treat these structures similar to the H/AMT and return concrete error types.

For structures like deadline state it's a bit more borderline, I could see either way working and this change is probably for the better. In Go there are some cases where the exit code is determined at that level (usually ErrIllegalArgument), but most just return an opaque error that turns into ErrIllegalState.

[anorth]

The challenge with moving the exit codes a bit lower will be ensuring consistency with the Go code. I traced this one as an example, and on all the paths I could find this results in ErrIllegalState in the Go implementation. Indeed, I'd say ErrIllegalState is your go-to for anything lower than the top-level actor calls, but those top-level call sites might sometimes be able to adapt into a better exit code.

ErrIllegalArgument is mostly only used at the top level when checking parameters directly provided by the user.

On this pass through I'm not going to check them all, but I'd say the default should be illegal_state to get maximal matching with current code. And then we need to decide how much we care about exactly matching the exit codes. We'll need to do so for all practical abort paths in order to maintain sync with mainnet.

[Stebalien]

Yeah, I wouldn't push actor errors down the stack like this as it can be difficult to pick a sane default. Really, the correct error here is likely "assertion failed".

[Stebalien]

We may be able to get away with more implicit conversions and custom error types?

[anorth]

This is nice

[anorth]

This is an interesting case that's illegal state in Go (by way of no exit code being specified at this level), but using illegal argument would be better.

[anorth]

Another interesting example case. This is illegal state in Go, and that's more correct because the cause of this is some inconsistency or broken invariants in the actor's state. This doesn't result from a bad parameter provided by top-level caller.

[dignifiedquire]

Added a custom error for bitfield_queue