lint: monitor current linting warnings on tracks

This is just a tracking issue, so that I'm not posting it in gists or release PRs. Later, I suppose I could link a personal repo that runs `configlet lint` on a schedule on every track.

At the time of posting, here are the tracks where `configlet lint` exits with an exit code of 0, but there is at least one warning:

#### csharp

```text
Warning: The following concepts exist in the `practices` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
linq
queues
stacks
multi-dimensional-arrays
streams
lazy-evaluation
recursion
yield
generic-methods
foreach
immutability
higher-order-functions
parallellism
comparing
generic-constraints
globalization
concurrency
big-integers
events

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but are not in the `concepts` array of any user-facing Concept Exercise
math-operators
integers
bit-manipulation
enumerables
queues
stacks
multi-dimensional-arrays
streams
generic-methods
lambdas
foreach
immutability
higher-order-functions
parallellism
lazy-evaluation
comparing
generic-constraints
globalization
observables
big-integers
events

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
integers
queues
stacks
multi-dimensional-arrays
streams
generic-methods
foreach
immutability
higher-order-functions
parallellism
lazy-evaluation
comparing
generic-constraints
globalization
observables
big-integers
events
```

#### factor

```text
Warning: The following concepts exist in the `practices` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
word-definition
stack-effect
strings
quotations
conditionals
math
collections
combinators

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but are not in the `concepts` array of any user-facing Concept Exercise
word-definition
stack-effect
strings
quotations
logical-operators
combinators
collections

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
word-definition
stack-effect
strings
quotations
logical-operators
combinators
collections
```

#### fortran

```text
Warning: The following concepts exist in the `practices` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
equality
conditionals

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but are not in the `concepts` array of any user-facing Concept Exercise
equality
conditionals

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
equality
conditionals
```

#### fsharp

```text
Warning: The following concepts exist in the `practices` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
string-formatting
generic-functions
ordering
equality
ranges
bit-manipulation
flag-discriminated-unions
regular-expressions
collection-processing
sets
result
members
concurrency
constructors
generic-types
immutability
integral-numbers
math-operators
while-loops
extension-methods
structs
yield
lazy-evaluation
operator-overloading
big-integers
randomness
exceptions
generic-methods
nullability
switch-statements
switch-expressions
globalization
parameters
casting
resource-cleanup
multi-dimensional-arrays
interfaces
parallellism
optional-parameters
for-loops
streams
string-builder
stacks
queues
comparing
generic-constraints
inheritance
events

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but are not in the `concepts` array of any user-facing Concept Exercise
options
generic-functions
higher-order-functions
integral-numbers
ordering
equality
string-formatting
ranges
chars
bit-manipulation
for-loops
result
constructors
members
classes
generic-types
math-operators
while-loops
extension-methods
immutability
structs
operator-overloading
big-integers
randomness
sets
exceptions
generic-methods
nullability
maps
flag-discriminated-unions
globalization
parameters
casting
resource-cleanup
multi-dimensional-arrays
interfaces
parallellism
optional-parameters
collection-processing
streams
stacks
queues
lazy-evaluation
comparing
generic-constraints
observables
inheritance
events

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
options
generic-functions
integral-numbers
ordering
equality
string-formatting
ranges
chars
bit-manipulation
for-loops
result
constructors
members
generic-types
math-operators
while-loops
extension-methods
immutability
structs
operator-overloading
big-integers
randomness
sets
exceptions
generic-methods
nullability
maps
flag-discriminated-unions
globalization
parameters
casting
resource-cleanup
multi-dimensional-arrays
interfaces
parallellism
optional-parameters
collection-processing
streams
stacks
queues
lazy-evaluation
comparing
generic-constraints
observables
inheritance
events
```

#### haxe

```text
Warning: The following concepts exist in the `practices` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
recursion

Warning: The Concept `strings` appears 15 times in the `practices` arrays of user-facing Practice Exercises, but can only appear at most 10 times:
./config.json

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but are not in the `concepts` array of any user-facing Concept Exercise
regular-expressions
strings
arrays
booleans
numbers
if-statements
for-loops
floating-point-numbers
integral-numbers
enums
exceptions
maps
basics
string-interpolation
bit-manipulation
optional-arguments
```

#### java

```text
Warning: The following concepts exist in the `practices` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
enums

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but are not in the `concepts` array of any user-facing Concept Exercise
enums

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
enums
```

#### javascript

```text
Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but are not in the `concepts` array of any user-facing Concept Exercise
dates
regular-expressions
recursion
codepoints
randomness
bit-manipulation
math
maps

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
dates
regular-expressions
codepoints
randomness
bit-manipulation
math
maps
```

#### red

```text
Warning: The following concepts exist in the `practices` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
series

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but are not in the `concepts` array of any user-facing Concept Exercise
basics
blocks
maths
strings
errors
```

#### ruby

```text
Warning: The following concepts exist in the `practices` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
regular-expressions
ordering
classes
hashes
casting
sets
equality
time
math-operators
enumerable
recursion
integral-numbers
constructors
lambdas
higher-order-functions
lazy-evaluation
stacks
bit-manipulation
symbols
parameters
randomness
queues
immutability
structs
dates
string-formatting

Warning: The Concept `strings` appears 21 times in the `practices` arrays of user-facing Practice Exercises, but can only appear at most 10 times:
./config.json

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but are not in the `concepts` array of any user-facing Concept Exercise
constructors
ordering
classes
hashes
casting
equality
time
integers
math-operators
enumerable
integral-numbers
generic-methods
lambdas
higher-order-functions
symbols
lazy-evaluation
stacks
bit-manipulation
parameters
randomness
queues
immutability
sets
structs
dates
string-formatting

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
constructors
ordering
classes
hashes
casting
equality
time
integers
math-operators
enumerable
integral-numbers
generic-methods
lambdas
higher-order-functions
symbols
lazy-evaluation
stacks
bit-manipulation
parameters
randomness
queues
immutability
sets
structs
dates
string-formatting
```

#### vbnet

```text
Warning: The following concepts exist in the `practices` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
optional-parameters
string-interpolation
yield
lambdas
foreach
arrays
linq
if-statements
for-loops
lists
ordering
stacks
numbers

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but are not in the `concepts` array of any user-facing Concept Exercise
optional-parameters
string-interpolation
lambdas
extension-methods
generic-types
enumerables
foreach
arrays
strings
integers
if-statements
for-loops
numbers
lists
constructors
ordering
chars
stacks
booleans
exceptions
enums

Warning: The following concepts exist in the `prerequisites` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
optional-parameters
string-interpolation
lambdas
extension-methods
generic-types
enumerables
foreach
arrays
strings
integers
if-statements
for-loops
numbers
lists
constructors
ordering
chars
stacks
booleans
exceptions
enums
```

#### wren

```text
Warning: The following concepts exist in the `practices` array of a Practice Exercise in `./config.json`, but do not exist in the top-level `concepts` array
strings
text-formatting
optional-values
lists
maps
enumeration
exceptions
numbers
loops
recursion
getters
fields
classes
sequences
operator-overloading
match
math

Warning: The Concept `strings` appears 20 times in the `practices` arrays of user-facing Practice Exercises, but can only appear at most 10 times:
./config.json
```

Start by running `configlet lint` against the named language tracks and compare its warnings with each track's `./config.json`. The issue lists concept and practice metadata warnings for csharp, factor, fortran, fsharp, haxe, java, javascript, red, ruby, vbnet, and wren; done is not defined beyond tracking the current output.

Written by the indexing model from the issue text.