I originally called this talloc_length(), but SAMBA upstream uses
talloc_array_length.

Use this to preserve the entire working directory.

It leads to numerous problems, such as the next ccanlint getting confused
trying to compile examples, and "-k examples_compile -k examples_exist"
giving bogus errors.

So instead we leave the temporary dir lying around and delete
individual files which aren't marked "keep".

Otherwise valgrind will report that tests leak memory.

This makes some cases simpler, where you no longer want malloc etc.
to fail.

Looks like the example was copy-n-pasted from the previous entry.

Brad suggested this after finding one such cut & paste in str:

rusty@vivaldi:~/devel/cvs/ccan/ccan/str$ ../../tools/ccanlint/ccanlint
Example: sections demonstrate appropriate function (examples_relevant): FAIL
/home/rusty/devel/cvs/ccan/ccan/str/str.h:64:Example for strcount doesn't mention it
Total score: 37/38

Before:
	$ tools/ccanlint/ccanlint -d ccan/talloc/
	Module's source code has no trailing whitespace (no_trailing_whitespace): FAIL
	: Total score: 0/1

After:
	$ tools/ccanlint/ccanlint -d ccan/talloc/
	Module's source code has no trailing whitespace (no_trailing_whitespace): FAIL
	talloc: Total score: 0/1

We simply build up the error string in score_file_error; a bit different
but simpler than current behaviour.  We keep around struct file_error
because some tests need it.

My refactoring introduced a bug: we need to set score=1 for the success case.

With the original layout, we got:
Summary:
An efficient allocator for blocks that don't need to be
....
Description:
resized or freed.

Makes reporting of documentation easier.

It in fact takes an object and a key to compare, not two keys.

The test case had the key as first element of the object, so it worked,
but ccanlint lost track of module dependencies due to this bug, and thus
would build submodules multiple times.

It leads to a memory leak if the allocation fails (as we reparent onto NULL).
Also, the extra allocation in the failure path increases test time for
failtest (under valgrind) by a factor of 2.

Unfortunately this means we have to reduce run-many from 1000 nodes to 100
(as forking under valgrind is really slow: test takes about 2 minutes with
100 nodes).

The data is not made a child of the tree: the nodes are made children of the
data.  So we must explicitly free the data objects.

This covers more code than simply doing an ordered delete/insert.

This allows us to both allocators which handle failure themselves, and
allocators which insert failures.

(Import from SAMBA commit 6f51a1f45bf4de062cce7a562477e8140630a53d):

this is the minimal fix for the problem Rusty found. I previously
thought that the best fix would be to change tc->parent to be valid
for all pointers, but that is expensive for realloc with large numbers
of child pointers, which is much more commmon than I expected it to
be.

A module designed to help test "never fails" functions like malloc.