Starting with:
* `key`
* `duration`
* `priority`
* `state`
* `resource_restrictions`
* `exception`
* `traceback`

Going to get that working, then handle the rest --
`dep_state` seems tricky to get right

Signed-off-by: Gil Forsyth <gil@forsyth.dev>

Working plan:
- All dependencies are also Tasks (they don't necessarily have a `runspec`
because they might be gathered from another worker)
- `dependents` and `dependencies` are sets of TaskState objects

Also treating `who_has` as a Task object level dict, where keys are the
dependency keys and workers is a list of workers who have that data

This is maybe... wrong?

Each dependency TaskState object should be itself (ish) so probably just needs
to be a list of workers

They are all key checks now

This should be the same as flight -> memory

Need to think about this more, but we don't want to count these up every time
the dashboard refreshes

Things are a bit more stable now

It is OK for there to be tasks that aren't in `self.tasks` yet, but not ok if
they don't have an assigned `state`

Tests (and everything else) should use `update_data` for this kind of (unusual)
call.

This also avoids special casing an otherwise absent Task object

Comment in code, too, but I was initially treating this as an error, but it can
happen as a regular part task execution where a task is re-routed but
`self.ready` isn't updated before we get here.

I think this probably isn't right, but I'm trying it out

Also removed adding a dep to `_missing_dep_flight` in one of the transition
functions -- that leads to it being excluded from the dep gather, which seems
circular in a bad way

And clean up a few commented out lines

And handle the possibility of a `cause` not existing in `self.tasks`

This doesn't include the `assert ts.key not in self.nbytes` -- since tasks are
created via `add_task`, they can have `nbytes` specified before-hand

And also restore said count to Worker `repr`

Co-authored-by: James Bourbeau <jrbourbeau@users.noreply.github.com>

This is a redundant bit of state tracking and overcomplicates things.
Instead, similar to `Worker.tasks` this maintains a count of the
executing tasks for reporting but relies on `TaskState` objects to keep
track of the task state.

Note that the removal of the `finally:` block, specifically, is because
_if_ the key has already been released, then `self.executing_count` is
already decremented so that particular check doesn't need to be run.

Co-authored-by: James Bourbeau <jrbourbeau@users.noreply.github.com>