Fix docs on runAjax.

The comment documenting runAjax was outdated in terms
of how that function works, referring to an old continuation-
based approach rather than the current two-thread
approach to dealing with long-running AJAX processing.
Add restartComet() for restarting comet cycle.

restartComet is meant for cases where, for example, a new
comet is added to toWatch and we want its presence
reflected immediately. Without it, we would have to wait for
the current comet request to finish, which could take up to
90s if the old comets had no further updates, and could
bottle up updates from the new comet for that long, because
the new comet wouldn’t be able to push its contents through
the old connection.
Separate registerComet and registerComets in JS.

registerComet is used for registering a single comet, while
registerComets is used to register multiple comets. This as
opposed to the previous form that had some nasty
overloading of parameter meanings to decide based on type
whether we were trying to set one or multiple comets.
AJAX requests now investigate cometAtEnd.

If cometAtEnd contains references to any comets, they are
sent down to the client, though their XHTML currently is not.
Add a prototypical API for S.addComet.

Compilation: negatory.
Move CometCreationInfo to CometActor.scala.

It was hanging out in Templates.scala for some reason,
where it had no relation to its containing file nor was it used
therein.
initCometActor now takes a CometCreationInfo.

This propagates through callInitCometActor and most
callers thereof. We leave most of LiftSession alone because
comet stuff there is about to get rewritten.

CometCreationInfo’s attributes also change names, to
more descriptive ones.
Add CometId case class.

CometId describes a comet uniquely in the session, and
consists of the comet type and the (possibly Empty) comet
name. The cometSetup SessionVar and nasyncComponents
ConcurrentHashMap both use CometId for indexing.

Not all places that interact with these have been updated,
as there are chunks of LiftSession that are about to get
extensively rewritten; as such, this doesn’t currently
compile.
Significantly reorganize comet find/setup stuff.

Things are split up a little more granularly. We also have a
more uniform and descriptive API (findComet only finds
existing comets, while findOrBuildComet is used to build a
comet if it wasn’t found). The API is still internal to Lift’s
packages.

This still doesn’t quite compile, as it breaks the Comet
snippet.
Expose comet finding/creation in S.

We now have S.findOrCreateComet in two forms, with a
type parameter and with a String cometType. We also use
this to make the Comet snippet work again.

Note that the Comet snippet used to support comets with no
types, but that is no longer acceptable.
Strip callInitCometActor overload.

This was the old non-CometCreationInfo overload for
callInitCometActor, which is no longer used.
Rework findOrBuildComet[T].

Instead of converting T to a simple type name and then going
through the usual comet lookup pipeline, we use the Class
instance given us by the manifest for T to directly try to
instantiate the class, which is just cleaner.
Consolidate functionality in comet building code.

This all in LiftSession, where the comet building code
refactoring had left some duplication littered around.
Add a comment to cometSetup SessionVar.
Fix some typos in LiftSession.
Align LiftSession<->S naming for comet creation.
Align docs for LiftSession<->S comet creation.
Comet UpdateDefaultXml message->UpdateDefaultHtml.

We’ve moved towards naming things “html” when dealing with
comets, so this follows that trend.
Add snippet failure type for missing comet type.
Rework Comet snippet.

In particular, the snippet now exposes a
Comet.containerForCometActor method that can be used by
an arbitrary third party consumer to produce the container for
a given comet actor when a handle to the LiftCometActor
object already exists.

It is, of course, still possible to materialize a CometActor using
regular lift:comet snippet.