Other answers have covered the the main part of the question, that rules do indeed allow you to express things that can't be expressed in OWL 2.
However, I wanted to answer some of the embedded "what is RIF" questions.
gerrit : "my understanding is that RIF is not really a rule language (although you can use it to construct rules), but rather a way of converting existing rule languages to vocabularies".
No, RIF is a format to allow rules to be interchanged, i.e. you can take rules out of one rule engine translate them to RIF, publish them, someone else can then translate them to their own rule engine and run them. Since it provides an exchange syntax and a semantics then it is also a rule language it is own right so someone could come along and implement RIF from scratch rather than implementing a translator if they wanted to.
Note RIF is actually an extensible family of rule languages not a single language. There is a production rule dialect (RIF PR) suited for exchange of business rules, a logic programming dialect (RIF BLD) which includes equality and a core dialect (RIF Core) which is the intersection of the two.
scottheninger : "A follow-on question I have is why we need RIF and SWRL when SPARQL can express rules with CONSTRUCT."
First, RIF is not specific to RDF. Indeed a lot of the motivation for RIF comes from exchange of business rules which are typically production rules running over XML or object data structures. SPARQL isn't really appropriate or sufficient for either the data or the semantics in that case.
Second, SPARQL Construct is not itself a rule language. As formally specified it just allows you to make a one step transformation from one graph match to another graph. It is true that you can then iteratively apply a set of SPARQL constructs and think of that as a rule language. However, you have to actually specify how that iteration is set up, how recursive rule behave, when the results of one iteration are made available (especially given that SPARQL in effect has negation-as-failure). This can be done in various ways which will have different implications. Axel Polleres has papers on this such as SPARQL Rules! which define a rule extension of SPARQL Construct using Answer Set semantics. TopQuadrant have their SPIN language which is based on using SPARQL Constructs but with different semantics[*].
Third, even restricting oneself to rules over RDF then RIF allows you to express things which you can't express as iterative SPARQL Constructs. Of course RIF BLD and RIF PR are each more expressive in their own way but even within the simple horn rule RIF Core dialect then are some useful extras. You have more builtins (e.g. list operators) and you have n-ary predicates which solve a lot of problems with building intermediate results which things like Jena Rules have to hack around with hidden predicates.
All that said, I think it would be really valuable to develop a SPARQL-friendly RIF Core syntax which would then make the links between iterated SPARQL and RIF clearer. RIF then brings a defined rule semantics, extra builtins and n-ary relations; SPARQL brings a friendly syntax for RDF developers and a simple route to a (brute force) implementation for at least a partial implementation.
[*] I believe SPIN that is based on a procedural semantics of iterative applications but don't know the details and don't know whether things like "refraction" and the conflict set resolution machinery of production rules is included.