Make pointer_equal a builtin.

There was an inline pragma on its definition, but most programs, including
the compiler, are (most of the time) not compiled with the intermodule
optimization options that would allow this to take effect. Making it a builtin
gets around this "problem".

compiler/builtin_ops.m:
    Add private_builtin.pointer_equal as a builtin op.

    Factor out some more commonalities between existing builtin ops.

compiler/bytecode.m:
    Add the new pointer_equal_conservative op. The bytecode backend
    doesn't handle it, but then again, it doesn't handle really anything
    else either.

compiler/c_util.m:
    Handle the new operator, including adding a new category for it.

compiler/llds.m:
compiler/ml_global_data.m:
    Record the output type of the new operator.

compiler/llds_out_data.m:
    Generate code for the new operator for the LLDS backend.

compiler/mlds_to_c.m:
compiler/mlds_to_cs.m:
compiler/mlds_to_java.m:
compiler/mlds_to_il.m:
    Generate code for the new operator for the MLDS backend
    when targeting C, C#, Java and IL respectively. The IL version
    just aborts, since I don't know IL well enough to know what
    code to generate for "false" (the conservative approximation,
    also used for Erlang), but this should be ok, since the backend
    is not functional anyway.

compiler/erl_call_gen.m:
    Generate code for the new operator for the ELDS backend.
    The code we generate always returns false, which is allowed by the
    operator, since this is a conservative approximation.

    Start using require_complete_switch to ensure that we handle all
    operators. Add code to handle the old operators that this code
    did not used to handle.

compiler/java_util.m:
    Add an XXX comment about a scheme to handle operators that does not allow
    anything similar to such a require_complete_switch.

compiler/opt_debug.m:
    Pretty print the new operator.

compiler/options.m:
    Allow the definition of builtins such as pointer_equal while this
    change is bootstrapped.

library/private_builtin.m:
    Remove the inline pragma from pointer_equal, because the compiler
    can't handle such a pragma for a builtin, even when being bootstrapped.
    This could be fixed, but isn't worth the bother. A compiler builtin
    is like an inline pragma that works even without intermodule optimization.