lib/n/time: support for (stackable) Clock and Sysclock

Add support to n.bench too.
lib/n/bench: ensure measure are active if they're used
bootstrap:scope: support redefining-while-using in inner scope: 'let x = x + 1'

We still do not allow redefining an identifier in the same block.

We've always allowed redefining an identifier in an inner scope. But
just like C doesn't allow
	int x = x + 1; // x is already in scope, the rhs 'x' is undefined
we didn't allow
	let x = x + 1

cprinter prints local identifiers with a trailing number to differentiate
the various nested versions:
	int x$1 = x + 1;
lib/n/fs: use new ability to 'let x = x + 1'
lib/n/env: Env globalenv for argv and environment variables

Use secure_getenv(3) and setenv(3).
bootstrap:inference: flexible return for except: allow even non `Default_ctor

We tolerate non-`Default_ctor, even with the constraints temporarily
disabled, as it will be allowed in the future.
bootstrap:inference: fill_in_optional_args: fix error reporting on missing positional
bootstrap:inference: rewrite_unary_call: no need to call fill_in_optional_args ourselves

We let catchup do it.
lib/n/fs: add mmap support
bootstrap;inference: _Ncodeloc: read expression as pos until next line

The previous logic was often not showing enough. This is still not
ideal, but often more useful.
bootstrap:cprinter: experiments with always_inline unconclusive

Using always_inline doesn't seem to be hugely beneficial, although there
appears to be a small improvement in runtime (<= 5%). As expected, the
nature of the generated code (accessors, many thin methods, etc) may
demand that we tweak inlining rules in the C compilers. But it's
reassuring that they seem to do a pretty good job on their own.
bootstrap:ncc0: NCC_VERBOSE and NCC_CFLAGS env vars
bootstrap: propagate local static constants, such as generated Codeloc

Turns out that C compiler will not optimize

	struct Codeloc c = { 0 };
	c.Line = 42;
	Assert__(cond, &c);

into, after inlining:

	if (cond) {
	  struct Codeloc c = { .Line = 42 }:
	  // print 'c' then abort
	}

Instead, we get something like:

	struct Codeloc c = { 0 };
	c.Line = 42;
	if (cond) {
	  // print 'c' then abort
	}

The cost of the copy that initializes 'c' is paid even if cond is false,
even though 'c' is not used outside of that branch. It appears the
compilers (gcc and clang) refuse to move the initialization of 'c' into
the only branch where it's used. Maybe they're not allowed to, but I
can't see why.

Instead, we generate the following code:

	static struct Codeloc c = { .Line = 42 };
	Assert__(cond, &c);

which optimizes nicely, as the initialization of 'c' is moved out of the
way entirely.

We reuse the global constant propagation logic, using a new flag
NODE_IS_LOCAL_STATIC_CONSTANT. It must used with care, as the wrong use
of 'static' would have dire consequences. It is currently applied only
to STRING nodes (which are truly immutable) and generated _Ncodeloc
arguments.

In general, we cannot use it on

	DEFNAME
	 IDENT(x)
	 NUMBER

as the location of 'x' may be modified.
bootstrap:topdeps: try to ensure builtins are always at the top of the dep tree

This may prove to be too restrictive.
bootstrap: newtype: allow member overrides and specific members

E.g.

	newtype Duration = I64
	Duration met Show ...
		-- custom show function
lib/n/builtins/string: String.Index: use glibc memmem(3) as it is much faster
lib/n/builtins/string: String.Decode/Encode: return unused slice

In the spirit of Read and Write
lib/n/time: Duration.Show: very similar to go's ToString()
b/strings: first example of a performance benchmark comparing N and C

This test is not very interesting as String.Index is implemented with
memmem(3) that is used by the C version.