Now I tested and discussed with claude, and had a working version of
this project.  The rest is to port the claude version to my own
writings.  So this serves as the starting point before that attempt.

In the new attempt the design is better, and a number of bugs were
found and supposedly fixed, so let us see how this goes at the end.

* chain/src/item/default/splone.rs: A function for finding the node to
  plant used to ignore the condition that the children should match.
  Now this is fixed.

Some bugs are fixed:

1. If a non-terminal expansion can be reduced immediately, previously
an extra node would be created that had no parents.  Now this strange
behaviour is corrected.

2. When performing reductions, a leaf non-terminal node would
previously be regarded as completed.  Now we will first try to
complete that node, and then determine if the completion is
successful, and finally determine the completedness according to the
result.

Of course some more tests are still pending, before I can confirm that
no more bugs lurk around.

* chain/src/item/default/splone.rs: Previouslt the function
  `split_node` used to split the parents of splitted nodes by an ugly
  logic.  Now that is moved into a dedicated function, which properly
  handles the splitting of parents, including the case when the new
  node is open whereas the old node is closed, in which situation we
  ought to put the new node under the opened node only, as a closed
  node cannot contain an open node as a child by definition.

* chain/src/item/default/splone.rs: Previously when we split nodes, we
  always clone the parent if the labels differ.  This turns out to be
  incorrect if the new label is open whereas the old label is closed.
  In that case, the old parent should not contain the new node as a
  child, as a closed node should not contain an open node.

  I am not yet entirely sure this fix is correct, so more test await
  us.

In the process of splitting, cloning, and planting the forest, I
forgot to check whether some cloned node of the node inquestion
satisfy the condition.  This used to cause forests that violate some
fundamental assumptions.  Now this is supposed to be fixed, but more
tests await us.

Previously the functions `is_prefix` and `plant` did not take the
situation of packed nodes into considerations.  That was because I
only dealt with non-packed nodes in the past: the fragment to test for
prefixes and for planting did not intersect the packed nodes in the
forest, and the grammar is so simple that the fragments do not contain
packed nodes.

Then a test revealed this situation, so I have to fix this lack of
considerations now.  This commit attempts to fix this issue.

From the newly added unit-tests, it seems that this fix works.  :)

Now the binding part is finished.

What remains is a bug encountered when planting a fragment to the
forest which intersects a packed node, which would lead to invalid
forests.  This will also cause problem when planting a packed
fragment, but until now my testing grammars do not produce packed
fragments, so this problem is not encountered yet.

I am still figuring out efficient ways to solve this problem.

There were two main issues in the previous version.

One is that there are lots of duplications of nodes when manipulating
the forest.  This does not mean that labels repeat: by the use of the
data type this cannot happen.  What happened is that there were cloned
nodes whose children are exactly equal.  In this case there is no need
to clone that node in the first place.  This is now fixed by checking
carefully before cloning, so that we do not clone unnecessary nodes.

The other issue, which is perhaps more important, is that there are
nodes which are not closed.  This means that when there should be a
reuction of grammar rules, the forest does not mark the corresponding
node as already reduced.  The incorrect forests thus caused is hard to
fix: I tried several different approaches to fix it afterwards, but
all to no avail.  I also tried to record enough information to fix
these nodes during the manipulations.  It turned out that recording
nodes is a dead end, as I cannot properly syncronize the information
in the forest and the information in the chain-rule machine.  Any
inconsistencies will result in incorrect operations later on.

The approach I finally adapt is to perform every possible reduction at
each step.  This might lead to some more nodes than what we need.  But
those are technically expected to be there after all, and it is easy
to filter them out, so it is fine, from my point of view at the
moment.

Therefore, what remains is to filter those nodes out and connect it to
the holy Emacs.  :D

I should have staged and committed these changes separately, but I am
too lazy to deal with that.

The main changes in this commit are that I added the derive macro that
automates the delegation of the Graph trait.  This saves a lot of
boiler-plate codes.

The second main change, perhaps the most important one, is that I
found and tried to fix a bug that caused duplication of nodes.  The
bug arises from splitting or cloning a node multiple times, and
immediately planting the same fragment under the new "sploned" node.
That is, when we try to splone the node again, we found that we need
to splone, because the node that was created by the same sploning
process now has a different label because of the planting of the
fragment.  Then after the sploning, we plant the fragment again.  This
makes the newly sploned node have the same label (except for the clone
index) and the same children as the node that was sploned and planted
in the previous rounds.

The fix is to check for the existence of a node that has the same set
of children as the about-to-be-sploned node, except for the last one,
which contains the about-to-be-planted fragment as a prefix.  If that
is the case, treat it as an already existing node, so that we do not
have to splone the node again.

This is consistent with the principle to not create what we do not
need.