ENH: Support for management of periodic events

I have been using a class similar to this for managing events that don't need to occur on every bar that has gotten good feedback from the community in forum posts. This is a first stab at adding it to Zipline.

The primary piece of code is the EventManager class, it helps to manage the trading days between events, and to make sure they don't get executed more than a certain number of times in a trading day. 

The EventManager class accepts a rule function which is called for a final entry decision when all other criteria has been met. I added some common rules that can be used as stand alone checks or as rules for the EventManager. 

Some rules require parameters at initialization so I used classes with __call__ methods so they can be passed to the EventManager and work the same as if a function was passed. 

Example Usage: 
This will buy 10 shares of Apple every other day on the 20th and 21st minute minute of the trading day. 
```
after_market_open = EventManager(period=2, 
                                 max_daily_hits=2,
                                 rule_func=AfterOpen(minutes=20))

def initialize(context):
    context.event = after_market_open

def handle_date(context, data):
    dt = get_datetime()
    if context.event.signal(dt):
        print dt
        order('AAPL', 10)
```

What happens if I have multiple functions that I want to be called with different rules?  For example, what if I want an early-morning function that creates positions, and then an end of day function that clears my positions?  Am I correct in reading this that we need a separate EventManager instance for each rule?  It seems like a cleaner API might work something like:

```
def start_of_day_func(context, data):
    do_stuff()

def end_of_day_func(context, data):
    do_stuff()

def initialize(context):
    manager = EventManager()
    manager.add_rule(AfterOpen(minutes=5), start_of_day_func)
    manager.add_rule(BeforeClose(minutes=5), end_of_day_func)
    context.manager = manager

def handle_data(context, data):
    # Calls each function whose rule indicates that it should be called.
    context.manager.handle_data(context, data)
```
At that point, it might even make sense to create an API for guaranteeing that this happens before/after the rest of your `handle_data` logic, e.g. something like:
```
def start_of_day_func(context, data):
    do_stuff()

def end_of_day_func(context, data):
    do_stuff()

def initialize(context):
    manager = EventManager()
    manager.add_rule(AfterOpen(minutes=5), start_of_day_func)
    manager.add_rule(BeforeClose(minutes=5), end_of_day_func)
    register_event_manager(manager)

def handle_data(context, data):
    # manager.handle_data is automatically called before/after the call to the main `handle_data`
    pass
```