bootstrap: fix optional argument handling; add epr and esay

We still have the rule that optional argument must be in order, if
present. We're really not sure about that one.
bootstrap: remove all remaining mentions of `ctor_with
bootstrap: infer trivial interfaces (ctor, dtor, copy, equality, order) and `return_by_copy

Infer these interfaces by default (unless the types of the field
disallow it, or a method definition is given).

That is, if all fields are `trivial_copy, then the struct is inferred to
be `trivial_copy.

In the near future, we will instead *assume* these interfaces, and
allow users to counter this assumption by implementing a
`nontrivial_ctor or `nontrivial_copy interface (say).

For this approach to be sane, we will need to infer interfaces like
`trivial_copy_but_owned (or maybe named `capturing_trivial_copy).
bootstrap: support isalist literals such as {`trivial_copy `trivial_ctor}

	alias `both = {`trivial_copy `trivial_ctor}
	intf `a =
	  isa `trivial_copy `trivial_ctor

`both and `a are different: `both is exactly the same as the combination
of the two interfaces `trivial_copy and `trivial_ctor, no more, no less.
I.e.
	a isa `both <=> a isa `trivial_copy and a isa `trivial_ctor

`a is however something more. While to implement `a you have to
implement `trivial_copy and `trivial_ctor, a new interface is being
defined, which can involve additional constraints. Ideally, these
additional requirements are somehow captured in code (semantic
constraints, examples), but they may only be in comments or in an
external document. I.e.

	a isa `a => a isa `trivial_copy and a isa `trivial_ctor
bootstrap:constraints: examples: snprint_constraint() output is unstable

As the underlying data structure is unordered, constraints don't get
printed the same way every time. Short term, we only check the length
of the generated string. Long term, we will be changing extensively the
constraint data structure.
bootstrap: autointf: infer and generate automatic interfaces

Previously, the language required that interfaces like `trivial_copy be
specified by the user. The compiler would then check that it was a legal
claim (although the bootstrap compiler didn't actually do that yet).

We are now changing this approach. Generally speaking, we are making the
choice of having more sensible automatisms in the language, rather than
forcing the user to state the obvious, which made the language more
verbose than necessary.

	struct t =
	  x	:i32
	  y	:i32
is obviously `trivial_copy, and there is no good reason to not do by default.

	struct u =
	  p	:@i32
is not `trivial_copy, but `trivial_copy_but_owned to track the capture
of the reference by the copy. Unlike in C++, we have enough semantic
information available that we can generate sane defaults.

We introduce interfaces such as `not_copyable to prevent the generation
of defaults (for instance, because the implementer wants a narrower
public API).

We also remove the automatically generated mk and new member functions.
Instead, we rely on {}:t for stack allocation and direct use of the heap
for dynamic allocations. We rely on ^init to ensure that a constructor
is called on dynamically allocated objects.

The goal here is to ensure that 'new' or 'alloc' is not a privileged
operation that belongs to the type. The type controls 'ctor', but
allocation is not its business. Anyone can allocate memory, as long as
they know the size. We want to properly decouple allocation from
construction.

We previously thought that 'new' could accept an optional dynamic
allocator argument, but that doesn't work anymore if sysheap is a
globalenv. Furthermore, the new approach allows for more flexible
allocation schemes.

Note that even non-inline, non-opaque exported structs can be allocated
by foreign code. In the near future, we will add the generated member
function for all types:
	intf `any =
	  fun sizeof = size