Replace/Augment AttributeDict with strong types

[maxfischer2781]

During refactoring the use of the generic AttributeDict in various places made it needlessly difficult to understand and change the code. My preference and suggestion is to use – not generally but where applicable – the strongly typed NamedTuple, Protocol, or similar instead.

This isn't really a single, actionable work item and various places may benefit from or even need AttributeDict. I would like to discuss and collect uses that we can refactor well.

---

As a practical example, the Executor interface would currently be typed as such: (omitting stdin_input for brevity)

class Executor(metaclass=ABCMeta):
    @abstractmethod
    async def run_command(self, command: str) -> AttributeDict:
        return NotImplemented

While the AttributeDict could have arbitrary keys/attributes, in practice it only contains stdout, stderr and exitcode. The point of the Executor interface is that client code does not care about the precise executor, meaning different attributes in the provided results would be ignored either way.
The code doesn't make that obvious to either automatic (e.g. an IDE) or manual (e.g. a coder) inspection, though.

Since the point of AttributeDict is to have attributes, we could express them strongly using NamedTuple/@dataclass for concrete types or Protocol for abstract types.

class CommandResult(NamedTuple):
    stdout: str
    stderr: str
    exitcode: int

class Executor(metaclass=ABCMeta):
    @abstractmethod
    async def run_command(self, command: str) -> CommandResult:
        return NotImplemented

Defining Protocols would be the least intrusive change, whereas NamedTuple would be the most intrusive (due to immutability), with @dataclass somewhere in the middle.