learn_all: learn all unknown src addresses

The learning application as previously written would not always learn
all mac addesses on the network, as it was sending packets to the
controller with an unknown destination rather than an unknown source.
Rather than checking for an unknown destination, the learning
application now checks for unknown sources to send to the controller.

This change will break broadcast traffic, as the check on unknown
destinations was what the application relied on to properly forward
broadcast traffic from the controller. An additional check that the
destination is a broadcast address fixes this issue while leaving the
rest of the code untouched.
sync_pol: use the last policy update as the current policy

The controller must keep track of the current, authoritative policy for
the network. While there may be delay in actually implementing that
policy on the network, that delay should be minimized.

Prior to this commit the controller used the current policy for the
application it was running to determine the current, authoritative
policy for the network. But when the user specifies a non-zero
policy_queue_size, the application's current policy may differ greatly
from the one installed on the network, and that difference may persist
for quite some time. The result is that many packets sent to the
controller will be subject to a policy that is significantly different
from the network policy that forwarded them to the controller in the
first place.

This commit changes the bookkeeping of the current policy so that the
current policy is determined when the controller begins to install the
latest policy update on the network.
Fix Camlp4 parser bug, replacing '=' with ':='

Also rationalize order of field names.
Fix bug in LocalCompiler described in #341.

The issue was that the Pattern.obscures function was *totally
bogus*. It was using a fold_left instead of a fold_right and not
dropping false values from the first table.

Fixing these errors means that

```
filter ethDst = 00:00:00:00:00:02; port := 2 |
filter ethDst = 00:00:00:00:00:01; port := 1 |
filter ethDst = ff:ff:ff:ff:ff:ff;
(filter port = 2; port := 1 | filter port = 1; port := 2)
```
compiles to a correct flow table:
```
flowtable for switch 0:
[{pattern={ethDst=00:00:00:00:00:02},action=Output(2),cookie=0,
 idle_timeout=Permanent,hard_timeout=Permanent}
{pattern={ethDst=00:00:00:00:00:01,port=2},action=,cookie=0,
idle_timeout=Permanent,hard_timeout=Permanent}
{pattern={ethDst=ff:ff:ff:ff:ff:ff,port=2},action=Output(1),cookie=0,
idle_timeout=Permanent,hard_timeout=Permanent}
{pattern={ethDst=00:00:00:00:00:01},action=Output(1),cookie=0,
idle_timeout=Permanent,hard_timeout=Permanent}
{pattern={ethDst=ff:ff:ff:ff:ff:ff,port=1},action=Output(2),cookie=0,
idle_timeout=Permanent,hard_timeout=Permanent}
{pattern={ethDst=ff:ff:ff:ff:ff:ff},action=,cookie=0,idle_timeout=Permanent,
hard_timeout=Permanent}
{pattern={},action=,cookie=0,idle_timeout=Permanent,hard_timeout=Permanent}]
```
Paranoid sync
raw_app: make raw_app abstract over value type
raw_app: implement lift and ap for Raw_app.t

Now that Raw_app.t can produce arbitrary values, an applicative
interface is possible. And appealing.
Add parser support for IPv4 netmasks.
Ulexing dependency.
filter: initial implementation of Pred module

Pred.t is the pred analogue of the app type for policy. It allows you to
create and compose applications that will produce pred updates in
response to network events.
filter: constructor for asyncronous Pred.t updates
Merge pull request #337 from frenetic-lang/sync_pol

sync_pol: use the last policy update as the current policy
filter: add partial application point to async_handler

The handler may want to store the update pipe for asynchronous updates.
The partial application point allows it to do so.
mk_op: Use mk_{seq,union} operations for app composition

These operators will eliminate extraneous policy fragments while
performing composition, which will make the result easier to read at the
very least.
Cleaner implementation of IP masks.
Try parsing IP addresses first.
filter: use mk_{and,or,not} predicate constructors
Move mask parsing from lexer to parser
Merge pull request #343 from frenetic-lang/masks_parser

Add parser support for IPv4 netmasks.
Merge pull request #342 from frenetic-lang/raw_app

Low-level app interface abstracts over value type