Add FlexiblePublish

## Overview

Adds support for the FlexiblePublish plugin, and fixes some bugs in run conditions (in particular, for the alwaysRun condition and the build status condition). These run conditions are frequently (and apparently, exclusively) used in conjunction with the flexible publish plugin, which is why they were fixed in one wad.

## Implementation

This wad includes 3 related changes:

### Build Status Condition

The build status condition was previously built using a SimpleCondition. Unfortunately, this generated the wrong XML for the Run Condition Plugin version 1.0: it was generating blobs of the form:

```
<condition class="org.jenkins_ci.plugins.run_condition.core.StatusCondition">
  <worstResult>SUCCESS</worstResult>
  <bestResult>FAILURE</bestResult>
</condition>
```

Whereas using the gui to configure a job generated XML of the form:

```
<condition class="org.jenkins_ci.plugins.run_condition.core.StatusCondition" plugin="run-condition@1.0">
  <worstResult>
    <name>FAILURE</name>
    <ordinal>2</ordinal>
    <color>RED</color>
    <completeBuild>true</completeBuild>
  </worstResult>
  <bestResult>
     <name>SUCCESS</name>
     <ordinal>0</ordinal>
     <color>BLUE</color>
     <completeBuild>true</completeBuild>
  </bestResult>
</condition>
```

Through further experimentation, we found that the `ordinal` tag was necessary and sufficient for jenkins to correctly process the job. Unfortunately, this meant we couldn't use a `SimpleCondition` for build status anymore, as the testing infrastructure wasn't able to handle `SimpleCondition` nodes with children.

### Always Run Condition

The Always Run condition was generating xml nodes with an incorrect class: they had `org.jenkins_ci.plugins.run_condition.core.AlwaysRunCondition` instead of `org.jenkins_ci.plugins.run_condition.core.AlwaysRun`. Due to how the `SimpleCondition` class was designed (it always adds 'Condition' to the name of the class), it was easier to create a new class for the AlwaysRunCondition.

### Flexible publisher

The flexible publish class was designed to use the existing contexts (the `PublisherContext`, the `AbstractStepContext`, and the `RunConditionFactory`) to be as simple as possible.

## Testing done

In addition to the included tests, we have been using this internally for a while via the following monkey patches:

```
        /*                                                                      
         * A condition that matches if the current build status is better than  
         * or equal to worstResult and worse than or equal to bestResult.       
         *                                                                      
         * Example - the following matches only successful builds.              
         *                                                                      
         *    condition {                                                       
         *        status 'SUCCESS', 'SUCCESS'                                   
         *    }                                                                 
         */                                                                     
        RunConditionContext.metaClass.status { String worstResult, String bestResult = null ->
            bestResult = bestResult ?: worstResult                              
                                                                                
            def statuses = [                                                    
                'SUCCESS',                                                         
                'UNSTABLE',                                                        
                'FAILURE',                                                         
                'NOT_BUILT',                                                       
                'ABORTED',                                                         
            ]                                                                      
                                                                                   
            assert statuses.contains(worstResult)                                  
            assert statuses.contains(bestResult)                                   
                                                                                   
            condition = new SimpleCondition(                                       
                name: 'Status',                                                    
                args: ['worstResult': {                                            
                    ordinal statuses.findIndexOf { it == worstResult }             
                }, 'bestResult': {                                                 
                    ordinal statuses.findIndexOf { it == bestResult }              
                }])                                                                
        }  

        /*                                                                         
         * Unfortunately, alwaysRun doesn't work in the current version of the  
         * dsl plugin - it creates an AlwaysRunCondition node, rather than an   
         * AlwaysRun node. We fix it here.                                         
         */                                                                        
        RunConditionContext.metaClass.alwaysRun { ->                               
            condition = new AlwaysRunCondition()                                   
        }                                                                          
                                                                                   
        PublisherContext.metaClass.flexible_publish { Closure closure ->           
                def innerContext = new FlexiblePublisherContext()                  
                AbstractContextHelper.executeInContext(closure, innerContext)   
                                                                                   
                publisherNodes << innerContext.node                                
        }   
```

With the FlexiblePublisherContext included below basically unchanged (the only difference is I added the asserts here).
The XML generation should happen in PublisherContext. The nested contexts should just gather the data.