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.
Replace associations with scopes

Too many associations where leveraging scopes will do - this gets of
half a dozen.

I've also renamed the unpublished_edition method as we now have the
concept on an unpublished edition, which isn't quite the same thing.
Epic search/replace: archived becomes superseded

This frees us up to repurpose "archived" to mean documents that are
still visible on the site, but are considered to be out of date. It
also migrates the data for existing archived editions. I've done this
as a normal migration as want to minimise the time between the data
being migrated and the new code becoming active. This is because any
attempts to publish editions between the data being migrated and the
new code becoming active will likely cause an exception to be thrown.