Issue title: Render with new style after setting style
 Issue body: As discussed on #1661, I think it makes sense to render features with the new style when someone calls `setStyleFunction`.  I'm open to arguments why it does not make sense to do this.

 Comments: 
 Comment 0: It does make sense. But styleFunction is a property (ol.Object sense) today, and changing a property triggers a propertychange event, as opposed to a change event.

If we want to trigger a change event when setStyleFunction is called we need to either make styleFunction an actual property on the layer (as opposed to an ol.Object property) or have the vector layer listen to change:stylefunction events on itself and also dispatch change events when change:stylefunction are received. With the latter option two events will be triggered, which will cause two renders to occur (one immediately and another one in the next animation frame). That's undesired.

And also, having styleFunction being an ol.Object property (obviously) makes the following possible:

``` js
var layer1 = new ol.layer.Vector({
  styleFunction: function(feature, resolution) {
    // ...
  }
});

var layer2 = new ol.layer.Vector({
});
layer2.bindTo('styleFunction', layer1);
```

I think it's quite nice but maybe not mandatory.

 Comment 1: > But styleFunction is a property (ol.Object sense) today, and changing a property triggers a propertychange event, as opposed to a change event.

This is an implementation detail that we are free to change.  It is not a argument to keep things the way they are (in my opinion).

 Comment 2: With apologies, I think the binding argument (though repeatedly invoked) is weak.  It is far more straightforward to use the same function on two layers if you want the same style on both.

The clear and very simple alternative is to remove `styleFunction` as an `ol.Object` property.  The same is needed (in my opinion) for `ol.Feature` (see #1668).

 Comment 3: > With apologies, I think the binding argument (though repeatedly invoked) is weak. It is far more straightforward to use the same function on two layers if you want the same style on both.

More straightforward but not identical.

``` js
layer2.bindTo('styleFunction', layer1);

// now that layer2's styleFunction is bound to layer1's I can freely change the
// style function on layer1, and layer1 and layer2 will still share the same
// function
layer1.setStyleFunction(function(feature, resolution) {
   //
});
```

Maybe I'm stating the obvious here.

Sentences like "I think the binding argument (though repeatedly invoked) is weak" makes me feel like going to bed :-)

 Comment 4: > Maybe I'm stating the obvious here.

Yes, understood :)

> Sentences like "I think the binding argument (though repeatedly invoked) is weak" makes me feel like going to bed :-)

Sorry Eric.  I'm frustrated that the `style` option wasn't discussed more thoroughly yesterday.  It is rough to go for a whole week between sync-ups.  I hope we can find a time for more discussion soon, as I think this ticket communication isn't enough.

 Comment 5: >  I'm frustrated that the style option wasn't discussed more thoroughly yesterday.

We just did not realize about all the implications.

 Comment 6: Ok, back to the diane60@example.net.  What are the arguments for **not** re-rendering features with the correct style when `setStyleFunction` is called?  And I'm not talking about reasons it doesn't currently work (I have no lack of understanding about the current implementation), just reasons it should not work this way in the future.

 Comment 7: >  What are the arguments for not re-rendering features with the correct style when setStyleFunction is called?

I don't have any. I'm saying there are cases where the user changes the styles without changing tge style function. For these cases we need to export dispatchChangeEvent and make the user responsible for calling that function.

 Comment 8: Right.  Or they could call `setStyle`.  I'm not opposed to exporting `dispatchChangeEvent`, but I think it is more straightforward to explain `setStyle` when describing how to change styles.

 Comment 9: Agree.

If style remains an ol.Object property of the layer I'm not sure how we can make the renderer behave differently when changing the style and when changing the opacity. I know it's just an implementation detail :-)

 Comment 10: Styles objects that can mutate is also relevant to the discussion. Right now they are non-mutable objects. There may be cases where mutable style objects would be useful. I'm not sure right now.

 Comment 11: This issue is addressed by the commits in #1690.

{'source': 'GithubIssues', 'repo_name_with_owner': 'openlayers/openlayers', 'issue_id': 27177782, 'repo_stars': 9526.0}