Implement efficient monitoring algorithm

Every struct hid_dev now has a timer to periodically begin a
monitoring interval. It is also necessary to allocate memory
for the hardware address of a temporary target for each
monitoring interval.

There are also bools for whether monitoring is currently
occuring, for determining whether contact has been made with
any neighbor during the current monitoring interval (to
diagnose network partitions), and for whether the neighbor has
yet been remonitored if failure is suspected.

Upon arrival of a neighbor list, the monitoring algorithm may
begin in process_neigh_list(). monitor() initiates a monitoring
interval, using pick_random_neigh() to select a random target
to monitor.

To accomplish this, the monitoring algorithm first pings the
selected target, which may result in a timer expiration and
callback of end_ping_failure(). In that case, investigative
neighbors may be used to verify that the given target has
failed. If, at the end of the investigative time period, no
response from the target has been received, a timer expiry
callbacks into end_interval_failure(), which may declare a
node as failed.

A function find_update_neigh_sc() is added to update the status
of a hardware address for which we don't have a struct
hrdw_addr reference. If we're updating a node that has failed,
we need to estimate the remote clock time using the difference
between the old clock time and the new clock time.

The forward declaration of end_interval_failure() is necessary
because of the cyclic nature between monitor(),
end_ping_failure(), and end_interval_failure().

In order to send monitoring packets, send_monitoring() is
implemented. Note that const u8 *inv should not be used
for Ping and Ack packets, and in those cases should be set to
NULL.

nwp_rcv() may now accept monitoring packets and distribute
them to process_monitoring(), which updates clocks, changes
timers, and dispatches packets as necessary depending on the
type of packet that has been received. When a monitoring
iteration is successful (an Ack is received), the monitoring
interval will end in end_interval_success().

Periodically, the neighbor list should be cleaned of any failed
nodes that have been declared dead for some time. The function
clean_neigh_list() is therefore added , which is periodically
called upon timer expiration.
Fix spelling of announcement

Fixed all spelling mistakes for "announcement."
Disable deletion of manually-entered neighbors

When a neighbor is manually added to the neighbor list via the xip
utility, that neighbor should not be removed from the neighbor list.
These nodes are kept in the neighbor list to keep routing compatible
in other XIA implementations.

To do this, insert_neigh() and new_ha() are given an additional
parameter, which requires a change in the prototype of insert_neigh()
in include/net/xia_hid.h. Every struct hrdw_addr now also has an
8-bit, unsigned flags field for whether the neighbor should be kept.
It is possible for this flag to take on the following bit values:

  * NWP_KEEP_ENTRY: if neighbor should not be deleted from the
    neighbor list at any time.
  * NWP_MIN_CLOCK: if any clock value is larger than the current
    remote clock.

Therefore, update_ha_sc() and find_update_neigh_sc() need to be aware
of the meanings of these values. Note that in find_update_neigh_sc(),
we can only remove the NWP_MIN_CLOCK flag if we are updating a neighbor
to ALIVE, since only in that case do we have a valid remote clock. In
update_ha_sc(), we have a valid remote clock in all cases so that flag
is always removed if it is present. clean_neigh_list() also should not
discard any neighbor who has a NWP_KEEP_ENTRY flag.