Add some documentation and simplify data model.

# Compliance

<!-- Much of this content appears too in doc.go

When changing this file consider whether the change also applies to doc.go -->

Package compliance provides an approved means for reading, consuming, and

analyzing license metadata graphs.

Assuming the license metadata and dependencies are fully and accurately

recorded in the build system, any discrepancy between the official policy for

open source license compliance and this code is **a bug in this code.**

## Naming

All of the code that directly reflects a policy decision belongs in a file with

a name begninning `policy_`. Changes to these files need to be authored or

reviewed by someone in OSPO or whichever successor group governs policy.

The files with names not beginning `policy_` describe data types, and general,

reusable algorithms.

The source code for binary tools and utilities appears under the `cmd/`

subdirectory. Other subdirectories contain reusable components that are not

`compliance` per se.

## Data Types

A few principal types to understand are LicenseGraph, LicenseCondition, and

ResolutionSet.

### LicenseGraph

A LicenseGraph is an immutable graph of the targets and dependencies reachable

from a specific set of root targets. In general, the root targets will be the

artifacts in a release or distribution. While conceptually immutable, parts of

the graph may be loaded or evaluated lazily.

Conceptually, the graph itself will always be a directed acyclic graph. One

representation is a set of directed edges. Another is a set of nodes with

directed edges to their dependencies.

The edges have annotations, which can distinguish between build tools, runtime

dependencies, and dependencies like 'contains' that make a derivative work.

### LicenseCondition

A LicenseCondition is an immutable tuple pairing a condition name with an

originating target. e.g. Per current policy, a static library licensed under an

MIT license would pair a "notice" condition with the static library target, and

a dynamic license licensed under GPL would pair a "restricted" condition with

the dynamic library target.

### ResolutionSet

A ResolutionSet is an immutable set of `AttachesTo`, `ActsOn`, `Resolves`

tuples describing how license conditions apply to targets.

`AttachesTo` is the trigger for acting. Distribution of the target invokes

the policy.

`ActsOn` is the target to share, give notice for, hide etc.

`Resolves` is the set of conditions that the action resolves.

For most condition types, `ActsOn` will be the target where the condition

originated. For example, a notice condition policy means attribution or notice

must be given for the target where the condition originates. Likewise, a

proprietary condition policy means the privacy of the target where the

condition originates must be respected. i.e. The thing acted on is the origin.

Restricted conditions are different. The infectious nature of restricted often

means sharing code that is not the target where the restricted condition

originates. Linking an MIT library to a GPL library implies a policy to share

the MIT library despite the MIT license having no source sharing requirement.

In this case, one or more resolution tuples will have the MIT license module in

`ActsOn` and the restricted condition originating at the GPL library module in

`Resolves`. These tuples will `AttachTo` every target that depends on the GPL

library because shipping any of those targets trigger the policy to share the

code.

## Processes

### ReadLicenseGraph

The principal means to ingest license metadata. Given the distribution targets,

ReadLicenseGraph populates the LicenseGraph for those root targets.

### NoticeIndex.IndexLicenseTexts

IndexLicenseTexts reads, deduplicates and caches license texts for notice

files. Also reads and caches project metadata for deriving library names.

The algorithm for deriving library names has not been dictated by OSPO policy,

but reflects a pragmatic attempt to comply with Android policy regarding

unreleased product names, proprietary partner names etc.

### projectmetadata.Index.MetadataForProjects

MetadataForProjects reads, deduplicates and caches project METADATA files used

for notice library names, and various properties appearing in SBOMs.

module_classes: "EXECUTABLES"

projects:  "standalone/binary"

license_kinds:  "SPDX-license-identifier-LGPL-2.0"

license_conditions:  "restricted"

license_conditions:  "restricted_allows_dynamic_linking"

license_texts:  "testdata/restricted/RESTRICTED_LICENSE"

is_container:  false

built:  "out/target/product/fictional/obj/EXECUTABLES/bin_intermediates/bin3"

module_classes: "EXECUTABLES"

projects:  "standalone/binary"

license_kinds:  "SPDX-license-identifier-LGPL-2.0"

license_conditions:  "restricted"

license_conditions:  "restricted_allows_dynamic_linking"

license_texts:  "testdata/restricted/RESTRICTED_LICENSE"

is_container:  false

built:  "out/target/product/fictional/obj/EXECUTABLES/bin_intermediates/bin3"

package_name:  "Device"

projects:  "device/library"

license_kinds:  "SPDX-license-identifier-LGPL-2.0"

license_conditions:  "restricted"

license_conditions:  "restricted_allows_dynamic_linking"

license_texts:  "testdata/restricted/RESTRICTED_LICENSE"

is_container:  false

built:  "out/target/product/fictional/obj/SHARED_LIBRARIES/lib_intermediates/liba.so"

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

// Much of this content appears too in README.md

// When changing this file consider whether the change also applies to README.md

/*

Package compliance provides an approved means for reading, consuming, and

artifacts in a release or distribution. While conceptually immutable, parts of

the graph may be loaded or evaluated lazily.

Conceptually, the graph itself will always be a directed acyclic graph. One

representation is a set of directed edges. Another is a set of nodes with

directed edges to their dependencies.

The edges have annotations, which can distinguish between build tools, runtime

dependencies, and dependencies like 'contains' that make a derivative work.

LicenseCondition

----------------

`ActsOn` is the target to share, give notice for, hide etc.

`Resolves` is the license condition that the action resolves.

Remember: Each license condition pairs a condition name with an originating

target so each resolution in a ResolutionSet has two targets it applies to and

one target from which it originates, all of which may be the same target.

`Resolves` is the set of condition types that the action resolves.

For most condition types, `ActsOn` and `Resolves.Origin` will be the same

target. For example, a notice condition policy means attribution or notice must

be given for the target where the condition originates. Likewise, a proprietary

condition policy means the privacy of the target where the condition originates

must be respected. i.e. The thing acted on is the origin.

For most condition types, `ActsOn` will be the target where the condition

originated. For example, a notice condition policy means attribution or notice

must be given for the target where the condition originates. Likewise, a

proprietary condition policy means the privacy of the target where the

condition originates must be respected. i.e. The thing acted on is the origin.

Restricted conditions are different. The infectious nature of restricted often

means sharing code that is not the target where the restricted condition