Rename "beta" to "prototype" and document support policy

Summary:
Fixes T6084. Changes:

  - Rename `phabricator.show-beta-applications` to `phabricator.show-prototypes`, to reinforce that these include early-development applications.
  - Migrate the config setting.
  - Add an explicit "no support" banner to the config page.
  - Rename "Beta" to "Prototype" in the UI.
  - Use "bomb" icon instead of "half star" icon.
  - Document prototype applications in more detail.
  - Explicitly document that we do not support these applications.

Test Plan:
  - Ran migration.
  - Resolved "obsolete config" issue.
  - Viewed config setting.
  - Browsed prototypes in Applications app.
  - Viewed documentation.

Reviewers: chad, btrahan

Reviewed By: btrahan

Subscribers: epriestley, hach-que

Maniphest Tasks: T6084

Differential Revision: https://secure.phabricator.com/D10493

src/docs/user/userguide/prototypes.diviner

@@ -0,0 +1,65 @@
+@title User Guide: Prototype Applications
+@group userguide
+
+Information about prototypes.
+
+Overview
+========
+
+Phabricator includes //prototype applications//, which are applications in an
+early stage of development.
+
+IMPORTANT: The upstream does not offer support for these applications.
+
+When we begin working on a new application, we usually implement it as a
+prototype first. This allows us to get a better sense of how the application
+might work and integrate with other applications, and what technical and product
+challenges it might face.
+
+Prototypes are often not generally usable. They usually aren't documented,
+don't have safety and correctness checks in place, very rarely have full
+integrations or APIs, and may be missing major pieces of critical functionality
+or even not work at all. The parts of an application we prototype first
+may not be the useful parts.
+
+Some applications leave the prototype phase quickly, but other applications may
+not. We build some prototypes just to make sure a specific technical barrier is
+surmountable, and may not finish the application for a very long time. In other
+cases, the prototype seems less interesting or useful once it starts working
+than we might have imagined it would be, or be far more challenging than we
+thought. We may lower the priority of a project or put it on hold indefinitely
+if we're less excited about it after we begin building it.
+
+If you're interested in previewing upcoming applications, you can use the
+`phabricator.show-prototypes` configuration setting to enable prototypes.
+
+Feedback on Prototypes
+======================
+
+We're usually interested in this sort of feedback on prototypes:
+
+  - {icon check, color=green} **Use Cases**: If we're building something that
+    you think you'd use, we'd love to hear about your use cases for it. This can
+    help us figure out what features to add and how users may think about, use,
+    and integrate the application.
+  - {icon check, color=green} **General Interest**: Is an application something
+    you're looking forward to? Knowing which applications users are interested
+    in can help us set priorities.
+
+We're usually **not** interested in this sort of feedback on prototypes:
+
+  - {icon times, color=red} **Support Requests**: We do not support these
+    applications. Use them at your own risk, or wait for them to leave the
+    prototype phase.
+  - {icon times, color=red} **Bug Reports**: We know these applications don't
+    work well yet, and usually know about most of the open bugs. Even if we
+    don't, whatever isn't working yet may change completely before the
+    application leaves the prototype phase.
+  - {icon times, color=red} **Contributions / Pull Requests**: These
+    applications are usually in too early a state to accept contributions. Let
+    us know about your use case, but wait for release to send code.
+
+Overall, using prototypes makes it easier for us to explore and develop
+application ideas, and to share a preview of what's coming in the future with
+users, but prototypes are not yet full applications and we do not provide
+support until applications leave the prototype phase.