Simplify PreviewController
Basic service objects for publishing/force-pub

This is work in progress for two of the service objects for Edition
workflow. There are a number of key features that have yet to be
fleshed out. Firstly, a number of post-publishing actions that are
currently handled in callback hooks on Edition or as Rails observers
are yet to be moved into the service objects. These are: GovUkDelivery
notifications; search (re)indexing; and the re-indexing of supporting
pages and related editions (handled by observers at present). There is
also the notification of relevant users, which is currently part of
the controller workflow (see notify_users_of_edition_publishing in
EditionWorkflowController).

Rather than having all these actions performed inline in the service
objects, my thinking was to use the observer pattern and a basic
pub/sub-style API to decouple these related actions from the core
business logic of publishing an edition. The code would look something
like this:

```ruby

class EditionPublisher
  attr_accessor :edition, listeners

  def initialize(edition, listeners=[GovDeliveryNotifier, EditionSearchIndexer, AuthorNotifier])
    @listeners = listeners
  end

  def perform!
    if can perform?
      publish_edition!
      listeners.each { |listener| listener.publish_succeeded(edition) }
      true
    else
      listeners.each { |listener| listener.publish_failed(edition) }
      false
    end
  end

  ...
end
```

So the default listeners would be injected in, but could be easily
overridden, not only in the tests, but also in other parts of the app
when necessary. For example, we might want to publish some editions
in a data cleanup script and skip the notifications, but still perform
the indexing. Or we might want to add additional listeners for logging
during an import.
Add pub/sub for callbacks to subscribers
Pull author publish notification from controller

This moves the logic for notifying authors of edition publication into
the service objects as registered subscribers.
Move gov delivery notifications to service object
Remove unused code

This was required to cleanup attachments with double-extensions. As
the bug that caused them is long fixed, we can get rid of this code.
Add missing behaviour to force publisher

Editions with a scheduled publication time should not be force
publishable.
Unstub ForcePublicationAttemptTest

These tests were tightly coupled to the previous mechanism for force-
publishing editions. Unstubbing them means they work with the new
service object-based publishing mechanism
Remove unnecessary guards from state machine

We now enforce publishing requirements in the EditionPublisher and
EditionForcePublisher service objects so these guards are now
redundant.
Move service objects to services folder
Extract search indexing to service subscriber

Callbacks still there for archiving, unpublishing and deleting until
those actions are pulled out to service objects.
Move supporting page indexing to service object

Once again, there is still observer code for unpublishing and
archiving that needs pulling out later.
Move related edition indexing to service object

The ReindexRelatedEditions class is still in the observer for now and
will need to be moved elsewhere once we have the unpublish service
object.
Remove now-redundant callbacks on publish
Sprinkle on some OO

Functionally the same, but arguably makes the code more readable.
Pull force-publish remark to service subscriber

This greatly simplifies EditionForcePublisher as it now mirrors the
basic behaviour of EditionPublisher - the only differences are in the
validations and the subscribers.
Simplify force publish service object logic

Because we are enforcing the presence of a force publishing reason in
the controller layer, and because it's a UI feature (i.e. we enfore
admin users provide a force publish reason, but may not necessarily
want to enforce that when force publishing editions in our own scripts
or data migrations), we don't need the service object to be aware of
the need for a reason. If one is not provided, no remark is saved.
This allows the Edition::ForcePublishLogger to be made into a more
generic Edition::EditorialRemarker, which both the EditionPublisher
and EditionForcePublisher can use. It also allows for the validation
logic between the two to be consolidated and gets rid of the smelly
"stub reason" when checking if the action can be performed.
Decouple subscribers from publishing services

The edition service objects should not need to have knowledge of the
callbacks/subscribers that are interested in their outcome. Instead,
we rely on another object to coordinate the subscription and
notification of interested parties - The Edition::ServiceCoordinator.
This uses the simple queue pub/sub class from within ActiveSupport to
push events back and forth.