Issue title: Question: Highlight background in CodeArea. 
 Issue body: ## Goal

I'm implementing an application that highlights differences between two JSON objects per button click. I'm using two code areas in which both JSON objects can be written into. These have to be code areas in order to highlight the syntax of the objects. This is done similar to the `JavaKeywordsDemo` with the exception of different patterns. 

When I calculate the differences I want to highlight them in the code area once I click the button by altering their background color. Whether the highlighted difference still obtains its syntax highlighting is irrelevant. 

## Expected Behavior

Given a `CodeArea area` and a `List<String> differences`. A button's action method is clicked that contains the `highlightDifferences()` method. The method changes the background color of the `area`. 

## Actual Behavior

When the button is clicked the background color is changed for a millisecond and gets reverted to regular syntax highlighting. 

## Reproducible Demo

I cannot provide the whole code as the application is quite massive but here are the respective parts: 

````java
public class CollectionController extends AbstractController {

... 
 /**
   * Highlights the differences of the given code area, i.e. changes the background color according
   * to the stylesheets.
   *
   * @param area The area to modify.
   * @param differences The properties that differ.
   */
  private void highlightDifferences(CodeArea area, List<String> differences) {
    String text = area.getText();

    // Traverse all differences.
    for (String difference : differences) {

      /*
       * Split the difference properties into individual strings. The : represents the value of the
       * property and should be ignored because it is on the same line as the property name.
       */
      difference = difference.replaceFirst("\\.", "").replaceAll(":", ".");
      String[] properties = difference.split("\\.");
      int from = 0;

      // Ignore the value.
      for (int i = 0; i < properties.length - 1; i++) {

        // Get the first index of the property including the leading " and the index of end of line.
        from = text.indexOf(properties[i], from) - 1;
        int to = text.indexOf("\n", from);

        // Highlight this range.
        area.setStyleClass(from, to, "highlight");
      }
    }
  }
...
public abstract class AbstractController implements Initializable {
...

/**
   * Initializes a given CodeArea. The code area does have line numbers on the left side,
   * syntax highlighting and auto-indent. This is being achieved within this method.
   *
   * @param area The {@code CodeArea} to initialize. 
   */
  void initializeCodeArea(CodeArea area) {
      ... 

    // Compute syntax highlighting.
    area.getVisibleParagraphs().addModificationObserver(new Highlighter<>(area, this38d1:d2b4:3d06:83e8:96a5:8c2:893d:aba5omputeHighlighting));

   ...
  }

...
````

## Environment info:

- RichTextFX Version: 10.5
- Operating System: Windows 10
- Java version: 14.0.2 


 Comments: 
 Comment 0: Can you please post the code for your Highlighter class. (You need to prevent your Highlighter class from overwriting your background color changes.)
 Comment 1: Sure, this is the highlighting and the Highlighter: 


``` java 
/**
   * Computes syntax highlighting for JSON Objects on a given text and returns its style spans.
   *
   * @param text The text to compute the highlighting on.
   * @return Essentially a list of given styles that span a certain length.
   */
  private StyleSpans<Collection<String>> computeHighlighting(String text) {

    // Get the patterns for styling.
    Matcher matcher = PATTERN.matcher(text);
    int lastNameIndex = 0;
    StyleSpansBuilder<Collection<String>> spansBuilder = new StyleSpansBuilder<>();

    // Find the different keywords for a JSON Object and style them accordingly. 
    while (matcher.find()) {
      String styleClass =
              matcher.group("NAME") != null
                      ? "name"
                      : matcher.group("PARENTHESIS") != null
                      ? "parenthesis"
                      : matcher.group("BRACE") != null
                      ? "brace"
                      : matcher.group("BRACKET") != null
                      ? "bracket"
                      : matcher.group("SEMICOLON") != null
                      ? "semicolon"
                      : matcher.group("STRING") != null
                      ? "string"
                      : matcher.group("NUMBER") != null ? "number" : null;
      assert styleClass != null;

      spansBuilder.add(Collections.emptyList(), matcher.start() - lastNameIndex);
      spansBuilder.add(Collections.singleton(styleClass), matcher.end() - matcher.start());
      lastNameIndex = matcher.end();
    }
    spansBuilder.add(Collections.emptyList(), text.length() - lastNameIndex);
    return spansBuilder.create();
  }

 /**
   * This class is used to syntax highlight code areas in JSON style.
   *
   * @param <PS> The paragraph style, e.g. alignment.
   * @param <SEG> The segment.
   * @param <S> The actual styling, e.g. colors.
   */
  private static class Highlighter<PS, SEG, S> implements Consumer<ListModification> {
    /** CodeArea is a child of this */
    private final GenericStyledArea<PS, SEG, S> area;

    /** The function to compute the styles */
    private final Function<String, StyleSpans<S>> computeStyles;

    /** The previous paragraph index */
    private int prevParagraph;

    /** The previous paragraph's text length */
    private int prevLength;

    /**
     * Constructs a Highlighter with a given area and highlight function.
     */
    public Highlighter(
            GenericStyledArea<PS, SEG, S> area, Function<String, StyleSpans<S>> computeStyles) {
      this.computeStyles = computeStyles;
      this.area = area;
    }

    /**
     * Performs the computeStyles function on the modifications.
     *
     * @param modifications Modifications to the text of the code area.
     */
    @Override
    public void accept(ListModification modifications) {
      if (modifications.getAddedSize() > 0) {

        // Get the current paragraph.
        int paragraph =
                Math.min(
                        area.firstVisibleParToAllParIndex() + modifications.getFrom(),
                area.getParagraphs().size() - 1);

        // Get the current text.
        String text = area.getText(paragraph, 0, paragraph, area.getParagraphLength(paragraph));
        
        if (paragraph != prevParagraph || text.length() != prevLength) {
          int startPos = area.getAbsolutePosition(paragraph, 0);
          Platform.runLater(() -> area.setStyleSpans(startPos, computeStyles.apply(text)));
          prevLength = text.length();
          prevParagraph = paragraph;
        }
      }
    }
  }
``` 

And this is the css part:
```css
/* difference highlighting */
.highlight {
    -rtfx-background-color: #FFCA74;
}

/* The "name" part of JSON Object name/value pairs */
.name {
    -fx-fill: #0009D3;
    -fx-font-weight: bold;
}

/* Semicolons within code areas */
.semicolon {
    -fx-font-weight: bold;
}

/** brackets within code areas */
.parenthesis, .brace, .bracket {
    -fx-fill: #00312C;
    -fx-font-weight: bold;
}

/** values of code areas. Note that these can be yrodriguez@example.org. */
.string, .number {
    -fx-fill: black;
}

``` 
 Comment 2: This is tricky, I'm wondering if it wouldn't be easier to accomplish this by adding your own selection like so ....

1.   Add a selection field to `AbstractController`, something like:

```java
Selection diffHighlighter;
```

   2.  Then in `initializeCodeArea` add the following: 

```java
diffHighlighter = new SelectionImpl<>( "highlight", codeArea );
codeArea.addSelection( diffHighlighter );
```

   3.  And in `highlightDifferences` replace _area.setStyleClass(from, to, "highlight");_ with:

```java
diffHighlighter.selectRange( from, to );
```
 Comment 3: unfortunately that didn't work when I tried it. :( 
 Comment 4: Ahh sorry I misread your use case .... I thought you were highlighting a single difference at a time with each button click, but you are highlighting all of them. So then maybe you should do the syntax and difference highlighting together instead of separately. because I think when you call _area.setStyleClass(from, to, "highlight");_ it triggers the syntax highlighting section of your code.
 Comment 5: An actual example might help. I have two JSON objects like: 

```json 
{
  "_id": {
    "$oid": "0001"
  },
  "name": {
     "firstName": "Fridolin",
     "lastName": "Smith"
  }, 
  "year": 2004,
  "class": 1,
  "city": "Berlin"
}
```

and 

```json 
{
  "_id": {
    "$oid": "0001"
  },
  "year": 2004,
  "name": {
     "firstName": "Fridolin",
     "lastName": "Schmidt"
  }, 
  "class": 1
}
```

within these two the value of the lastName differs and it has a city property but nothing else. so the first area would have 

`differences: ".name.lastname: \"Smith\"", ".city: \"Berlin\"` 

now i want to highlight `city: "Berlin"`, `"name": {` and `"lastName": "Smith"`
 Comment 6: > Ahh sorry I misread your use case .... I thought you were highlighting a single difference at a time with each button click, but you are highlighting all of them. So then maybe you should do the syntax and difference highlighting together instead of separately. because I think when you call _area.setStyleClass(from, to, "highlight");_ it triggers the syntax highlighting section of your code.

I'm having a total of 5 code areas of which only two do have this comparison and the other two are on a separate controller. I'd probably need to have another `computeHighlighting(List<String> differences)` and pass them as argument to the now overloaded `initializeCodeArea(CodeArea area, Function <String, Stylespans<S>> compute)`? 

Any hints on how to best practice this? 

 Comment 7: Best practice I can't say ..... but here's a hack. In `Highlighter.accept` put after `if (modifications.getAddedSize() > 0)`

```java
boolean highlight = lm.getAddedSubList().get( 0 ).getStyledSegments().stream()
         .anyMatch( ss -> ss.getStyle().toString().contains( "highlight" ) );
         
if ( highlight ) return;
```
 Comment 8: This actually works perfectly. Thanks a lot ! 
{'source': 'GithubIssues', 'repo_name_with_owner': 'FXMisc/RichTextFX', 'issue_id': 706280350, 'repo_stars': 1061.0}