Work on my doubly-connected edge list so I can complete some other things below!
Implement the continuous parametric transformations from 2020-05-07 in my notes. This will require some new abstractions.
Document parametric_mesh better. It is pretty hairy and could also benefit from some modularity.
Get identical or near-identical meshes to ramhorn_branch from Python. (Should just be a matter of tweaking parameters.)
Look at performance.
- Start at to_mesh_iter(). The cost of small appends/connects seems to be killing performance.
- connect() is a big performance hot-spot: 85% of total time in one test, around 51% in extend(), 33% in clone(). It seems like I should be able to share geometry with the Rc (like noted above), defer copying until actually needed, and pre-allocate the vector to its size (which should be easy to compute).
See automata_scratch/examples.py and implement some of the tougher examples.
- twisty_torus, spiral_nested_2, & spiral_nested_3 are all that remain. To do them, I need to compose transformations (not in the matrix sense), but I also probably need to produce RuleEvals which always have xf of identity transformation since the Python code does not 'inherit' transforms unless I tell it to.

Important but less critical:

Docs on modules
Compute global scale factor, and perhaps pass it to a rule (to eventually be used for, perhaps, adaptive subdivision). Note that one can find the scale factors by taking the length of the first 3 columns of the transform matrix (supposedly).
swept-isocontour stuff from /mnt/dev/graphics_misc/isosurfaces_2018_2019/spiral*.py. This will probably require that I figure out parametric curves
Make an example that is more discrete-automata, less approximation-of-space-curve.
Catch-alls:
- Grep for all TODOs in code, really.
- Look at everything in README.md in automata_scratch.

If I'm bored:

Look in https://www.nalgebra.org/quick_reference/# for "pour obtain". Can I fix this somehow? Looks like a French-ism that made its way in.
Multithread! This looks very task-parallel anywhere that I branch.
Would being able to name a rule node (perhaps conditionally under some compile-time flag) help for debugging?
Use an actual logging framework.
Take a square. Wrap it around to a torus. Now add a twist (about the axis that is normal to the square). This is simple, but it looks pretty cool.
How can I take tangled things like the cinquefoil and produce more 'iterative' versions that still weave around?

Generalizing to space curves moves this away from the "discrete automata" roots, but it still ends up needing the machinery I made for discrete automata.
If you pre multiply a transformation: you are transforming the entire global space. If you post multiply: you are transforming the current local space.