Add an "oid" layer to motifd.

* The wire protocol between motifd and Lisp employs 32-bit handles for
  various types; on 32-bit systems, the pointer address has been used,
  but that's lossy on 64-bit systems. This changeset introduces a
  32-bit handle called an "oid", and keeps a process-global
  doubly-linked list associating oids with pointers.
Fix bugs around XmTextField's callbacks.

* On the motifd side, writing callbacks with reason
  XmCR_MODIFYING_TEXT_VALUE would segfault when the text was NULL
  (e.g., due to backspacing).

* On the Lisp side, decoding of callbacks in READ-CALLBACK-INFO used
  the :TEXT for the widget-type, when the correct type is :TEXT-FIELD.
Remove some printf debugging in write_text_callback.
XEvents need to be trafficked as oids, too.

* There might only be one place where Lisp needs to indicate an XEvent
  back to motifd, in XmMenuPosition, but raw pointers won't cut it.
Rename "oblist.*" to "oid.*" (since the data structure is incidental).
Fix #84: motifd is 64-bit app.

Merge Richard Kreuter's clm-oids branch to master.  This allows
motifd to work even if motifd is a 64-bit app.  From Richard:

...the server passes out 32-bits of a pointer as external IDs for
instances of a handful of types [1]. On a 64-bit machine, the instances'
addresses might not fit in a 32-bit address, though.

(In fact, on my FreeBSD/amd64 machine, when I run the example from the
documentation, the first shell widget always gets created at
create the second widget with the shell as parent crashes the server.)

Seems like there are two options:

A. Change the wire protocol to accomodate 64-bit integers.

B. Synthesize 32-bit identifiers for instances of the offending types.

Option B seems simpler....

[It] suffices to run the example in the doc and the programs in
INTERFACE.... Obvious problems in the current code:

1. It's a doubly linked alist associating pointers with 32-bit integers.

2. It looks like nothing ever gets removed from the alist....

3. I'm not certain that I've caught all the places where motifd hands
   out pointers to Lisp.

[1] I think the complete list is AcceleratorTable, Atom, FontList,
TranslationTable, Widget, and sometimes XmString.
Fix motifd text callback.

Merge fix from Richard Kreuter's clm-text-callback branch. This fixes an
issue where text callbacks get nil. The test case is clm-young::numeric
from Richard Kreuter.  Without this patch, running (clm-young::numeric)
and entering digits and characters causes errors[1].  With this patch,
digits can be entered, and non-digits are correctly rejected.

[1] On linux. For whatever reason, this works on darwin/x86 even without
    this patch.
Fix issue in sending a boolean created from a pointer in
RXmStringEtLtoR.

Fix from Richard Kreuter.  This makes his clm-young::chooseone demo
work reliably.  Richard writes:

    The detail that this patch affects is non-deterministic:

    RXmStringGetLtoR in xmstring.c calls message_write_boolean on a
    pointer, message_write_boolean in datatrans.c calls
    combine_type_and_data with the pointer and the boolean type tag,
    and combine_type_and_data in datatrans.h IORs the boolean type tag
    with the bits 25 to 32 from the start of the pointer.

    This gave a decoding error on the Lisp side in TOOLKIT-READ-VALUE,
    because the high 8 bits of the 32 bits being decoded indexed past
    the end of *TYPE-TABLE*. (But other incorrect outcomes are
    possible, e.g., the result of combine_type_and_data could index a
    valid, but wrong, type code, etc.)