TODO

* Convert all class objects to be of the inside-out variety rather than
hash-based, so to gain rigorous protection against external code directly
accessing our object attributes, and to avoid related maintenance problems.

* Redo the input validation architecture to throw exceptions that are more
helpful.  Do what Carp does to determine where in the caller code we were
invoked badly, and cite the problem as occurring there, possibly with a
stack trace from that point upward.  Do not name the invoked method and
offending method arg in the core error message any more; they can be part
of the caller line or trace info.  All the work should be doable in a
single _throw* function that knows its context as Carp does.  State errors
based on what is attempted, rather than tying it to args; eg, "can't set
Node attribute 'foo' to an undefined value".

* Data dictionary update to make routine definitions more Pascal-like, such
that function return values are defined like out-args, and you assign to
said arg prior to exiting in order to return a value; then, 'return' takes
no arguments.

* Finish implementing the new Group class enough that write-blocks work.

* Do some serious refactoring / design changing of Rosetta.pm.

* Add a /demos folder, starting with a trivial cmd-line genealogy app.

* Once the above are done, announce Rosetta Developer Release #4.

* Implement the in-model transactional features and Node mutexes.

* Continue fleshing out the standard_routine enumerated type documentation.

* Add more deferred constraints to reduce erroneous models.

* Add another container_type that is analagous to a cursor except it
represents a handle for a large scalar value (LOB); external code can then
define that they won't try to hold them entirely in RAM at once like
ordinary scalars.

* Add support for arguments to cursors that are shared between multiple
routines and that are either opened more than once and/or opened in a
different routine than where the cursor is declared (that holds the
cursor-defining view).  In the mean time, cursor definitions can only take
arguments that are provided in the same routine where they are declared, as
part of the cursor-defining view.

* Find some efficient way to maintain an index of surrogate ids for Nodes
so that using them isn't as expensive.  Currently, the code is optimized
for those people that don't use surrogate ids, and there is no overhead for
index maintenance.  After the change, index maintenance itself should have
a very low overhead or they may be more trouble than they're worth.  The
use of them should perhaps be controlled by a boolean Container property.

* Add support to Literal Interfaces and/or another new Interface type to
elegantly handle large scalar values (LOBs) so we don't try to hold them
entirely in RAM at once.

* Keep watch on the separately released "Rosetta-Engine-Generic" and
"Rosetta-Emulator-DBI" and ensure we continue to meet their needs.

* Strive for complete code coverage in the tests.
