Add some missing backticks and remove redundant spaces

Some references to code symbols (classes, methods…) were enclosed in
backticks, and others weren't. I think this styling should be consistent
across features, and that backticks are better for readability, so I put
some everywhere I could see they were missing.

features/built_in_matchers/be_within.feature

@@ -10,7 +10,7 @@ Feature: `be_within` matcher
       > area_of_circle == 28.2743338823081
         => false
 
-  Instead, you should use the be_within matcher to check that the value is within a delta of
+  Instead, you should use the `be_within` matcher to check that the value is within a delta of
   your expected value:
 
     ```ruby

features/built_in_matchers/cover.feature

@@ -1,9 +1,9 @@
 @ruby-1.9
 Feature: `cover` matcher
 
-  Use the cover matcher to specify that a range covers one or more
-  expected objects. This works on any object that responds to #cover?
-  (such as a Range):
+  Use the `cover` matcher to specify that a range covers one or more
+  expected objects. This works on any object that responds to `#cover?`
+  (such as a `Range`):
 
     ```ruby
     expect(1..10).to cover(5)

features/built_in_matchers/exist.feature

@@ -1,6 +1,6 @@
 Feature: `exist` matcher
 
-  The exist matcher is used to specify that something exists (as indicated by #exist? or #exists?):
+  The `exist` matcher is used to specify that something exists (as indicated by `#exist?` or `#exists?`):
 
     ```ruby
     expect(obj).to exist # passes if obj.exist? or obj.exists?

features/built_in_matchers/include.feature

@@ -1,7 +1,7 @@
 Feature: `include` matcher
 
-  Use the include matcher to specify that a collection includes one or more expected objects.
-  This works on any object that responds to #include?  (such as a string or array):
+  Use the `include` matcher to specify that a collection includes one or more expected objects.
+  This works on any object that responds to `#include?` (such as a string or array):
 
     ```ruby
     expect("a string").to include("a")

features/built_in_matchers/match.feature

@@ -1,7 +1,7 @@
 Feature: `match` matcher
 
-  The match matcher calls `#match` on the object, passing if `#match` returns a truthy (not
-  `false` or `nil`) value.  Regexp and String both provide a `#match` method.
+  The `match` matcher calls `#match` on the object, passing if `#match` returns a truthy (not
+  `false` or `nil`) value. `Regexp` and `String` both provide a `#match` method.
 
     ```ruby
     expect("a string").to match(/str/) # passes

features/built_in_matchers/respond_to.feature

@@ -1,6 +1,6 @@
 Feature: `respond_to` matcher
 
-  Use the respond_to matcher to specify details of an object's interface.  In its most basic form:
+  Use the `respond_to` matcher to specify details of an object's interface. In its most basic form:
 
     ```ruby
     expect(obj).to respond_to(:foo) # pass if obj.respond_to?(:foo)
@@ -21,8 +21,8 @@ Feature: `respond_to` matcher
     expect(obj).to respond_to(:bar).with(2).arguments
     ```
 
-  Note that this matcher relies entirely upon #respond_to?.  If an object dynamically responds
-  to a message via #method_missing, but does not indicate this via #respond_to?, then this
+  Note that this matcher relies entirely upon `#respond_to?`.  If an object dynamically responds
+  to a message via `#method_missing`, but does not indicate this via `#respond_to?`, then this
   matcher will give you false results.
 
   Scenario: basic usage

features/built_in_matchers/satisfy.feature

@@ -1,6 +1,6 @@
 Feature: `satisfy` matcher
 
-  The satisfy matcher is extremely flexible and can handle almost anything you want to
+  The `satisfy` matcher is extremely flexible and can handle almost anything you want to
   specify. It passes if the block you provide returns true:
 
     ```ruby

features/built_in_matchers/throw_symbol.feature

@@ -1,6 +1,6 @@
 Feature: `throw_symbol` matcher
 
-  The throw_symbol matcher is used to specify that a block of code throws a symbol. The most
+  The `throw_symbol` matcher is used to specify that a block of code throws a symbol. The most
   basic form passes if any symbol is thrown:
 
     ```ruby

features/composing_matchers.feature

@@ -54,7 +54,7 @@ Feature: Composing Matchers
             by( a_value_within(0.1).of(1.0) )
         end
 
-        specify "you can pass matchers to `from` and `to" do
+        specify "you can pass matchers to `from` and `to`" do
           s = "food"
           expect { s = "barn" }.to change { s }.
             from( a_string_matching(/foo/) ).