Tiny Validity class

Unnecessary in parameter

The in string parameter modifier is what sticks out the most. I'm not sure what benefit this has over a regular string parameter. Strings are allocated on the heap in C#, so all you ensure with the in modifier is that you get the same pointer... which you get anyways by passing it as a regular string. Furthermore, strings are immutable.

Specifying the in modifier is useful for value types where you do want to pass by value, but prevent the code in this constructor from modifying it.

If you desire immutability in your Validity class, refactor your properties to have a readonly backing field:

public bool IsValid { get; }
public string ReasonForInvalid { get; }
//                                   ^ (no 'set;' between the curly braces)

Unnecessarily Verbose Comments

The second thing that stands out are the comments. The comments seem rather verbose for what the class does. Consider rewriting the comments as quick one-liners. For example, the comment for the parameterless constructor is:

/// <summary>
///     <para>
///         The default parameterless constructor assumes:
///         <code>
///             IsValid == true
///         </code>
///         and expects no reason for it whatsoever.
///     </para>
/// </summary>

This can be rewritten as:

/// <summary>
///     Initialize a new Validity object marking it valid with no reason provided.
/// </summary>

Much more clear and concise. Likewise, the other constructor comment can be rewritten from:

/// <summary>
///     <para>
///         The second constructor assumes:
///         <code>
///             IsValid == false
///         </code>
///         and expects a reason for being invalid.
///     </para>
/// </summary>

To:

/// <summary>
///     Initialize a new Validity object marking it invalid for the given reason.
/// </summary>

Class Constraints Are Not Enforced

If a reason is required, then the following code should throw an exception:

new Validity(null);
new Validity("");
new Validity("  \t  ");

Consider checking if (string.IsNullOrWhiteSpace(aReasonForInvalid)) and throwing an ArgumentNullException if it returns true.

On a related note, aReasonForInvalid doesn't need the a at the beginning. Simply calling it reasonForInvalid is enough. The phrase "reason for invalid" is also not grammatically correct. It could be reasonForInvalidity or simply reason would work as well. Even naming the parameter message and the property Message would work.

All "Valid" Objects Are The Same

Consider the case where you want a "valid" validity object. Code will initialize a new object each time. Consider adding a public static field to represent a valid validity object:

public class Validity
{
    /// <summary>
    /// Returns a Validity object representing a valid value.
    /// </summary>
    public static readonly Validity Valid = new Validity();

    private Validity()
    {
        IsValid = true;
    }

    /// <summary>...</summary>
    public Validity(string reasonForInvalid)
    {
        ...

Since the original code requires calling two different constructors (new Validitory() versus new Validity(string)) the static field allows you to give it a good name.

var validity = x > 5 ? Validity.Valid
                     : new Validity("x must be more than 5");

This allows your code to reuse the "valid" validity object, since the state of each "valid" object is the same. No need to allocate more memory to store the same exact values.