Fix the following issue:

# Persist sublattice metadata atomically and track the root dispatch

When the dispatcher runs a workflow that contains sublattices, each sublattice is
itself dispatched and gets its own lattice record in the results database. Two
things are currently awkward about how those records are created.

First, the database column that links a sublattice's lattice record back to the
parent electron that spawned it (`electron_id`) is only filled in *after* the
sublattice has already been written to the database. There is a window during
which a sublattice record exists with no link to its parent, so an interruption
can leave it orphaned. We want the parent electron id to be written in the *same*
insertion that creates the lattice record, not in a later update.

Second, we are about to need a way to identify, for any (sub)lattice in a
hierarchy, the dispatch id of the top-level ("root") workflow that ultimately
kicked everything off. A nested sublattice three levels deep should still be able
to report the dispatch id of the original top-level dispatch.

Please make the following behavior available.

## `root_dispatch_id` on the result object

The result object should expose a read-only `root_dispatch_id`. For a result
object that represents a top-level dispatch, this equals its own dispatch id. A
result object constructed for a given dispatch id reports that same id as its
root dispatch id until it is told otherwise (see the factory below).

## Persisting a parent electron id atomically

Persisting a result object should optionally accept the database id of the parent
electron that spawned this workflow. When provided, that id must be stored on the
lattice record in the very same transaction that first creates the lattice
record — not written by a subsequent update. When it is not provided, the
lattice record's `electron_id` stays null. Persisting a top-level workflow must
continue to behave exactly as before (its `electron_id` is null).

## A factory for building a result object from a serialized lattice

Add a convenience factory, importable as
`covalent._results_manager.result.initialize_result_object`, that constructs and
persists a result object from a JSON-serialized lattice. It takes the JSON
lattice and, optionally, a parent result object and a parent electron id:

```
initialize_result_object(json_lattice, parent_result_object=None, parent_electron_id=None)
```

It must:

- deserialize the lattice and assign the new result object a freshly generated,
  unique dispatch id (two calls never collide);
- initialize the result object's nodes and persist it before returning, passing
  along the parent electron id so it lands atomically on the lattice record as
  described above;
- when a parent result object is supplied (i.e. this lattice is a sublattice),
  make the new result object inherit the parent's `root_dispatch_id` rather than
  using its own dispatch id;
- return the fully constructed result object.

The returned result object's own dispatch id must still be distinct from its
parent's.